root/src/xdisp.c

DEFINITIONS

1. it_char_has_category
2. char_can_wrap_before
3. char_can_wrap_after
4. fill_column_indicator_column
5. redisplay_other_windows
6. wset_redisplay
7. fset_redisplay
8. bset_redisplay
9. bset_update_mode_line
10. wset_update_mode_line
11. ATTRIBUTE_FORMAT_PRINTF
12. ATTRIBUTE_FORMAT_PRINTF
13. window_text_bottom_y
14. window_box_width
15. window_box_height
16. window_box_left_offset
17. window_box_right_offset
18. window_box_left
19. window_box_right
20. window_box
21. window_box_edges
22. line_bottom_y
23. DEFUN
24. default_line_pixel_height
25. string_from_display_spec
26. window_hscroll_limited
27. reset_box_start_end_flags
28. pos_visible_p
29. check_char_and_length
30. string_pos_nchars_ahead
31. string_pos
32. c_string_pos
33. number_of_chars
34. compute_string_pos
35. estimate_mode_line_height
36. pixel_to_glyph_coords
37. x_y_to_hpos_vpos
38. frame_to_window_pixel_xy
39. get_glyph_string_clip_rects
40. get_glyph_string_clip_rect
41. get_phys_cursor_geometry
42. remember_mouse_glyph
43. adjust_window_ends
44. hscrolling_current_line_p
45. safe_eval_handler
46. safe__call
47. safe_call
48. safe_call1
49. safe__call1
50. safe_eval
51. safe__eval
52. safe_call2
53. CHECK_IT
54. CHECK_WINDOW_END
55. init_iterator
56. get_narrowed_width
57. get_narrowed_len
58. get_medium_narrowing_begv
59. get_medium_narrowing_zv
60. get_nearby_bol_pos
61. get_small_narrowing_begv
62. get_large_narrowing_begv
63. get_large_narrowing_zv
64. unwind_narrowed_begv
65. start_display
66. in_ellipses_for_invisible_text_p
67. init_from_display_pos
68. init_to_row_start
69. init_to_row_end
70. handle_stop
71. compute_stop_pos
72. compute_display_string_pos
73. compute_display_string_end
74. handle_fontified_prop
75. face_at_pos
76. handle_face_prop
77. underlying_face_id
78. face_before_or_after_it_pos
79. handle_invisible_prop
80. setup_for_ellipsis
81. find_display_property
82. get_display_property
83. display_min_width
84. handle_display_prop
85. handle_display_spec
86. display_prop_end
87. handle_single_display_spec
88. display_prop_intangible_p
89. single_display_spec_string_p
90. display_prop_string_p
91. string_buffer_position_lim
92. string_buffer_position
93. handle_composition_prop
94. handle_overlay_change
95. next_overlay_string
96. compare_overlay_entries
97. load_overlay_strings
98. get_overlay_strings_1
99. get_overlay_strings
100. push_it
101. iterate_out_of_display_property
102. restore_face_box_flags
103. pop_it
104. back_to_previous_line_start
105. strings_with_newlines
106. forward_to_next_line_start
107. back_to_previous_visible_line_start
108. reseat_at_previous_visible_line_start
109. reseat_at_next_visible_line_start
110. reseat
111. reseat_1
112. reseat_to_string
113. lookup_glyphless_char_display
114. merge_escape_glyph_face
115. merge_glyphless_glyph_face
116. forget_escape_and_glyphless_faces
117. get_next_display_element
118. set_iterator_to_next
119. next_element_from_display_vector
120. get_visually_first_element
121. next_element_from_string
122. next_element_from_c_string
123. next_element_from_ellipsis
124. next_element_from_image
125. next_element_from_xwidget
126. next_element_from_stretch
127. compute_stop_pos_backwards
128. handle_stop_backwards
129. next_element_from_buffer
130. next_element_from_composition
131. move_it_in_display_line_to
132. move_it_in_display_line
133. move_it_to
134. move_it_vertically_backward
135. move_it_vertically
136. move_it_past_eol
137. move_it_by_lines
138. partial_line_height
139. fast_move_it_horizontally
140. in_display_vector_p
141. window_text_pixel_size
142. DEFUN
143. format_nargs
144. add_to_log
145. vadd_to_log
146. message_log_maybe_newline
147. message_dolog
148. message_log_check_duplicate
149. message3
150. message_to_stderr
151. message3_nolog
152. message1
153. message1_nolog
154. message_with_string
155. ATTRIBUTE_FORMAT_PRINTF
156. message
157. update_echo_area
158. ensure_echo_area_buffers
159. with_echo_area_buffer
160. with_echo_area_buffer_unwind_data
161. unwind_with_echo_area_buffer
162. setup_echo_area_for_printing
163. display_echo_area
164. display_echo_area_1
165. resize_echo_area_exactly
166. resize_mini_window_1
167. resize_mini_window
168. current_message
169. current_message_1
170. push_message
171. restore_message
172. pop_message_unwind
173. check_message_stack
174. clear_message_stack
175. truncate_echo_area
176. truncate_message_1
177. set_message
178. set_message_1
179. clear_message
180. clear_garbaged_frames
181. echo_area_display
182. window_buffer_changed
183. mode_line_update_needed
184. window_frozen_p
185. format_mode_line_unwind_data
186. unwind_format_mode_line
187. store_mode_line_noprop_char
188. store_mode_line_noprop
189. gui_consider_frame_title
190. needs_no_redisplay
191. prepare_menu_bars
192. update_menu_bar
193. restore_selected_window
194. restore_frame_selected_window
195. update_tab_bar
196. display_tab_bar
197. build_desired_tab_bar_string
198. display_tab_bar_line
199. tab_bar_height
200. redisplay_tab_bar
201. tab_bar_item_info
202. get_tab_bar_item
203. get_tab_bar_item_kbd
204. handle_tab_bar_click
205. note_tab_bar_highlight
206. tty_get_tab_bar_item
207. tty_handle_tab_bar_click
208. update_tool_bar
209. build_desired_tool_bar_string
210. display_tool_bar_line
211. tool_bar_height
212. redisplay_tool_bar
213. tool_bar_item_info
214. get_tool_bar_item
215. handle_tool_bar_click_with_device
216. handle_tool_bar_click
217. note_tool_bar_highlight
218. hscroll_window_tree
219. hscroll_windows
220. debug_method_add
221. text_outside_line_unchanged_p
222. redisplay
223. overlay_arrow_string_or_property
224. overlay_arrow_in_current_buffer_p
225. overlay_arrows_changed_p
226. update_overlay_arrows
227. overlay_arrow_at_row
228. check_point_in_composition
229. reconsider_clip_changes
230. propagate_buffer_redisplay
231. redisplay_internal
232. unwind_redisplay_preserve_echo_area
233. redisplay_preserve_echo_area
234. unwind_redisplay
235. unwind_display_working_on_window
236. mark_window_display_accurate_1
237. mark_window_display_accurate
238. disp_char_vector
239. block_buffer_flips
240. unblock_buffer_flips
241. buffer_flipping_blocked_p
242. redisplay_windows
243. redisplay_window_error
244. redisplay_window_0
245. redisplay_window_1
246. update_redisplay_ticks
247. set_cursor_from_row
248. run_window_scroll_functions
249. cursor_row_fully_visible_p
250. try_scrolling
251. compute_window_start_on_continuation_line
252. try_cursor_movement
253. set_vertical_scroll_bar
254. set_horizontal_scroll_bar
255. window_start_acceptable_p
256. DEFUN
257. redisplay_window
258. try_window
259. try_window_reusing_current_matrix
260. find_last_row_displaying_text
261. find_last_unchanged_at_beg_row
262. find_first_unchanged_at_end_row
263. sync_frame_with_window_matrix_rows
264. row_containing_pos
265. try_window_id
266. dump_glyph_row
267. dump_glyph
268. dump_glyph_row
269. DEFUN
270. DEFUN
271. DEFUN
272. get_overlay_arrow_glyph_row
273. insert_left_trunc_glyphs
274. row_hash
275. compute_line_metrics
276. clear_position
277. append_space_for_newline
278. extend_face_to_end_of_line
279. trailing_whitespace_p
280. highlight_trailing_whitespace
281. row_for_charpos_p
282. cursor_row_p
283. push_prefix_prop
284. get_it_property
285. get_line_prefix_it_property
286. handle_line_prefix
287. unproduce_glyphs
288. find_row_edges
289. display_count_lines_logically
290. display_count_lines_visually
291. maybe_produce_line_number
292. should_produce_line_number
293. row_text_area_empty
294. display_line
295. DEFUN
296. DEFUN
297. DEFUN
298. display_menu_bar
299. deep_copy_glyph_row
300. display_tty_menu_item
301. redisplay_mode_lines
302. display_mode_lines
303. display_mode_line
304. move_elt_to_front
305. safe_set_text_properties
306. display_mode_element
307. store_mode_line_string
308. pint2str
309. pint2hrstr
310. decode_mode_spec_coding
311. percent99
312. decode_mode_spec
313. count_lines
314. display_count_lines
315. display_string
316. invisible_prop
317. DEFUN
318. calc_pixel_width_or_height
319. get_font_ascent_descent
320. dump_glyph_string
321. init_glyph_string
322. append_glyph_string_lists
323. prepend_glyph_string_lists
324. append_glyph_string
325. get_char_face_and_encoding
326. get_glyph_face_and_encoding
327. get_char_glyph_code
328. fill_composite_glyph_string
329. fill_gstring_glyph_string
330. fill_glyphless_glyph_string
331. fill_glyph_string
332. fill_image_glyph_string
333. fill_xwidget_glyph_string
334. fill_stretch_glyph_string
335. get_per_char_metric
336. normal_char_ascent_descent
337. normal_char_height
338. gui_get_glyph_overhangs
339. left_overwritten
340. left_overwriting
341. right_overwritten
342. right_overwriting
343. set_glyph_string_background_width
344. glyph_string_containing_background_width
345. compute_overhangs_and_x
346. draw_glyphs
347. font_for_underline_metrics
348. append_glyph
349. append_composite_glyph
350. take_vertical_position_into_account
351. produce_image_glyph
352. produce_xwidget_glyph
353. append_stretch_glyph
354. produce_stretch_glyph
355. produce_special_glyphs
356. pad_mode_line
357. calc_line_height_property
358. append_glyphless_glyph
359. produce_glyphless_glyph
360. gui_produce_glyphs
361. gui_write_glyphs
362. gui_insert_glyphs
363. gui_clear_end_of_line
364. get_specified_cursor_type
365. set_frame_cursor_types
366. get_window_cursor_type
367. notice_overwritten_cursor
368. gui_fix_overlapping_area
369. draw_phys_cursor_glyph
370. erase_phys_cursor
371. display_and_set_cursor
372. update_window_cursor
373. update_cursor_in_window_tree
374. gui_update_cursor
375. gui_clear_cursor
376. draw_row_with_mouse_face
377. show_mouse_face
378. clear_mouse_face
379. coords_in_mouse_face_p
380. cursor_in_mouse_face_p
381. rows_from_pos_range
382. mouse_face_from_buffer_pos
383. fast_find_string_pos
384. mouse_face_from_string_pos
385. on_hot_spot_p
386. find_hot_spot
387. define_frame_cursor1
388. note_mode_line_or_margin_highlight
389. note_mouse_highlight
390. gui_clear_window_mouse_face
391. cancel_mouse_face
392. expose_area
393. expose_line
394. expose_overlaps
395. phys_cursor_in_rect_p
396. gui_draw_vertical_border
397. gui_draw_right_divider
398. gui_draw_bottom_divider
399. expose_window
400. expose_window_tree
401. expose_frame
402. gui_intersect_rectangles
403. gui_union_rectangles
404. syms_of_xdisp
405. init_xdisp
406. show_hourglass
407. start_hourglass
408. cancel_hourglass
409. adjust_glyph_width_for_mouse_face
410. get_cursor_offset_for_mouse_face

     1 /* Display generation from window structure and buffer text.
     2 
     3 Copyright (C) 1985-2023 Free Software Foundation, Inc.
     4 
     5 This file is part of GNU Emacs.
     6 
     7 GNU Emacs is free software: you can redistribute it and/or modify
     8 it under the terms of the GNU General Public License as published by
     9 the Free Software Foundation, either version 3 of the License, or (at
    10 your option) any later version.
    11 
    12 GNU Emacs is distributed in the hope that it will be useful,
    13 but WITHOUT ANY WARRANTY; without even the implied warranty of
    14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    15 GNU General Public License for more details.
    16 
    17 You should have received a copy of the GNU General Public License
    18 along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.  */
    19 
    20 /* New redisplay written by Gerd Moellmann <gerd@gnu.org>.
    21 
    22    Redisplay.
    23 
    24    Emacs separates the task of updating the display from code
    25    modifying global state, e.g. buffer text.  This way functions
    26    operating on buffers don't also have to be concerned with updating
    27    the display.
    28 
    29    Updating the display is triggered by the Lisp interpreter when it
    30    decides it's time to do it.  This is done either automatically for
    31    you as part of the interpreter's command loop or as the result of
    32    calling Lisp functions like `sit-for'.  The C function
    33    `redisplay_internal' in xdisp.c is the only entry into the inner
    34    redisplay code.
    35 
    36    The following diagram shows how redisplay code is invoked.  As you
    37    can see, Lisp calls redisplay and vice versa.
    38 
    39    Under window systems like X, some portions of the redisplay code
    40    are also called asynchronously, due to mouse movement or expose
    41    events.  "Asynchronously" in this context means that any C function
    42    which calls maybe_quit or process_pending_signals could enter
    43    redisplay via expose_frame and/or note_mouse_highlight, if X events
    44    were recently reported to Emacs about mouse movements or frame(s)
    45    that were exposed.  And such redisplay could invoke the Lisp
    46    interpreter, e.g. via the :eval forms in mode-line-format, and as
    47    result the global state could change.  It is therefore very
    48    important that C functions which might cause such "asynchronous"
    49    redisplay, but cannot tolerate the results, use
    50    block_input/unblock_input around code fragments which assume that
    51    global Lisp state doesn't change.  If you don't follow this rule,
    52    you will encounter bugs which are very hard to explain.  One place
    53    that needs to take such precautions is timer_check, some of whose
    54    code cannot tolerate changes in timer alists while it processes
    55    timers.
    56 
    57    +--------------+   redisplay     +----------------+
    58    | Lisp machine |---------------->| Redisplay code |<--+
    59    +--------------+   (xdisp.c)     +----------------+   |
    60           ^                                  |           |
    61           +----------------------------------+           |
    62             Block input to prevent this when             |
    63             called asynchronously!                       |
    64                                                          |
    65                     note_mouse_highlight (asynchronous)  |
    66                                                          |
    67                                     X mouse events  -----+
    68                                                          |
    69                             expose_frame (asynchronous)  |
    70                                                          |
    71                                    X expose events  -----+
    72 
    73    What does redisplay do?  Obviously, it has to figure out somehow what
    74    has been changed since the last time the display has been updated,
    75    and to make these changes visible.  Preferably it would do that in
    76    a moderately intelligent way, i.e. fast.
    77 
    78    Changes in buffer text can be deduced from window and buffer
    79    structures, and from some global variables like `beg_unchanged' and
    80    `end_unchanged'.  The contents of the display are additionally
    81    recorded in a `glyph matrix', a two-dimensional matrix of glyph
    82    structures.  Each row in such a matrix corresponds to a line on the
    83    display, and each glyph in a row corresponds to a column displaying
    84    a character, an image, or what else.  This matrix is called the
    85    `current glyph matrix' or `current matrix' in redisplay
    86    terminology.
    87 
    88    For buffer parts that have been changed since the last update, a
    89    second glyph matrix is constructed, the so called `desired glyph
    90    matrix' or short `desired matrix'.  Current and desired matrix are
    91    then compared to find a cheap way to update the display, e.g. by
    92    reusing part of the display by scrolling lines.  The actual update
    93    of the display of each window by comparing the desired and the
    94    current matrix is done by `update_window', which calls functions
    95    which draw to the glass (those functions are specific to the type
    96    of the window's frame: X, w32, NS, etc.).
    97 
    98    Once the display of a window on the glass has been updated, its
    99    desired matrix is used to update the corresponding rows of the
   100    current matrix, and then the desired matrix is discarded.
   101 
   102    You will find a lot of redisplay optimizations when you start
   103    looking at the innards of redisplay.  The overall goal of all these
   104    optimizations is to make redisplay fast because it is done
   105    frequently.  Some of these optimizations are implemented by the
   106    following functions:
   107 
   108     . try_cursor_movement
   109 
   110       This function tries to update the display if the text in the
   111       window did not change and did not scroll, only point moved, and
   112       it did not move off the displayed portion of the text.
   113 
   114     . try_window_reusing_current_matrix
   115 
   116       This function reuses the current matrix of a window when text
   117       has not changed, but the window start changed (e.g., due to
   118       scrolling).
   119 
   120     . try_window_id
   121 
   122       This function attempts to redisplay a window by reusing parts of
   123       its existing display.  It finds and reuses the part that was not
   124       changed, and redraws the rest.  (The "id" part in the function's
   125       name stands for "insert/delete", not for "identification" or
   126       somesuch.)
   127 
   128     . try_window
   129 
   130       This function performs the full, unoptimized, redisplay of a
   131       single window assuming that its fonts were not changed and that
   132       the cursor will not end up in the scroll margins.  (Loading
   133       fonts requires re-adjustment of dimensions of glyph matrices,
   134       which makes this method impossible to use.)
   135 
   136    The optimizations are tried in sequence (some can be skipped if
   137    it is known that they are not applicable).  If none of the
   138    optimizations were successful, redisplay calls redisplay_windows,
   139    which performs a full redisplay of all windows.
   140 
   141    Note that there's one more important optimization up Emacs's
   142    sleeve, but it is related to actually redrawing the potentially
   143    changed portions of the window/frame, not to reproducing the
   144    desired matrices of those potentially changed portions.  Namely,
   145    the function update_frame and its subroutines, which you will find
   146    in dispnew.c, compare the desired matrices with the current
   147    matrices, and only redraw the portions that changed.  So it could
   148    happen that the functions in this file for some reason decide that
   149    the entire desired matrix needs to be regenerated from scratch, and
   150    still only parts of the Emacs display, or even nothing at all, will
   151    be actually delivered to the glass, because update_frame has found
   152    that the new and the old screen contents are similar or identical.
   153 
   154    Desired matrices.
   155 
   156    Desired matrices are always built per Emacs window.  It is
   157    important to know that a desired matrix is in general "sparse": it
   158    only has some of the glyph rows "enabled".  This is because
   159    redisplay tries to optimize its work, and thus only generates
   160    glyphs for rows that need to be updated on the screen.  Rows that
   161    don't need to be updated are left "disabled", and their contents
   162    should be ignored.
   163 
   164    The function `display_line' is the central function to look at if
   165    you are interested in how the rows of the desired matrix are
   166    produced.  It constructs one row in a desired matrix given an
   167    iterator structure containing both a buffer position and a
   168    description of the environment in which the text is to be
   169    displayed.  But this is too early, read on.
   170 
   171    Glyph rows.
   172 
   173    A glyph row is an array of `struct glyph', where each glyph element
   174    describes a "display element" to be shown on the screen.  More
   175    accurately, a glyph row can have up to 3 different arrays of
   176    glyphs: one each for every display margins, and one for the "text
   177    area", where buffer text is displayed.  The text-area glyph array
   178    is always present, whereas the arrays for the marginal areas are
   179    present (non-empty) only if the corresponding display margin is
   180    shown in the window.  If the glyph array for a marginal area is not
   181    present its beginning and end coincide, i.e. such arrays are
   182    actually empty (they contain no glyphs).  Frame glyph matrices, used
   183    on text-mode terminals (see below) never have marginal areas; they
   184    treat the entire frame-wide row of glyphs as a single large "text
   185    area".
   186 
   187    Iteration over buffer and strings.
   188 
   189    Characters and pixmaps displayed for a range of buffer text depend
   190    on various settings of buffers and windows, on overlays and text
   191    properties, on display tables, on selective display.  The good news
   192    is that all this hairy stuff is hidden behind a small set of
   193    interface functions taking an iterator structure (`struct it')
   194    argument.
   195 
   196    Iteration over things to be displayed is then simple.  It is
   197    started by initializing an iterator with a call to `init_iterator',
   198    passing it the buffer position where to start iteration.  For
   199    iteration over strings, pass -1 as the position to `init_iterator',
   200    and call `reseat_to_string' when the string is ready, to initialize
   201    the iterator for that string.  Thereafter, calls to
   202    `get_next_display_element' fill the iterator structure with
   203    relevant information about the next thing to display.  Calls to
   204    `set_iterator_to_next' move the iterator to the next thing.
   205 
   206    Besides this, an iterator also contains information about the
   207    display environment in which glyphs for display elements are to be
   208    produced.  It has fields for the width and height of the display,
   209    the information whether long lines are truncated or continued, a
   210    current X and Y position, the face currently in effect, and lots of
   211    other stuff you can better see in dispextern.h.
   212 
   213    The "stop position".
   214 
   215    Some of the fields maintained by the iterator change relatively
   216    infrequently.  These include the face of the characters, whether
   217    text is invisible, the object (buffer or display or overlay string)
   218    being iterated, character composition info, etc.  For any given
   219    buffer or string position, the sources of information that affects
   220    the display can be determined by calling the appropriate
   221    primitives, such as `Fnext_single_property_change', but both these
   222    calls and the processing of their return values is relatively
   223    expensive.  To optimize redisplay, the display engine checks these
   224    sources of display information only when needed, not for every
   225    character.  To that end, it always maintains the position of the
   226    next place where it must stop and re-examine all those potential
   227    sources.  This is called "the stop position" and is stored in the
   228    `stop_charpos' field of the iterator.  The stop position is updated
   229    by `compute_stop_pos', which is called whenever the iteration
   230    reaches the current stop position and processes it.  Processing a
   231    stop position is done by `handle_stop', which invokes a series of
   232    handlers, one each for every potential source of display-related
   233    information; see the `it_props' array for those handlers.  For
   234    example, one handler is `handle_face_prop', which detects changes
   235    in face properties, and supplies the face ID that the iterator will
   236    use for all the glyphs it generates up to the next stop position;
   237    this face ID is the result of "realizing" the face specified by the
   238    relevant text properties at this position (see xfaces.c).  Each
   239    handler called by `handle_stop' processes the sources of display
   240    information for which it is "responsible", and returns a value
   241    which tells `handle_stop' what to do next.
   242 
   243    Once `handle_stop' returns, the information it stores in the
   244    iterator fields will not be refreshed until the iteration reaches
   245    the next stop position, which is computed by `compute_stop_pos'
   246    called at the end of `handle_stop'.  `compute_stop_pos' examines
   247    the buffer's or string's interval tree to determine where the text
   248    properties change, finds the next position where overlays and
   249    character composition can change, and stores in `stop_charpos' the
   250    closest position where any of these factors should be reconsidered.
   251 
   252    Handling of the stop position is done as part of the code in
   253    `get_next_display_element'.
   254 
   255    Producing glyphs.
   256 
   257    Glyphs in a desired matrix are normally constructed in a loop
   258    calling `get_next_display_element' and then `PRODUCE_GLYPHS'.  The
   259    call to `PRODUCE_GLYPHS' will fill the iterator structure with
   260    pixel information about the element being displayed and at the same
   261    time will produce glyphs for it.  If the display element fits on
   262    the line being displayed, `set_iterator_to_next' is called next,
   263    otherwise the glyphs produced are discarded, and `display_line'
   264    marks this glyph row as a "continued line".  The function
   265    `display_line' is the workhorse of filling glyph rows in the
   266    desired matrix with glyphs.  In addition to producing glyphs, it
   267    also handles line truncation and continuation, word wrap, and
   268    cursor positioning (for the latter, see `set_cursor_from_row').
   269 
   270    Frame matrices.
   271 
   272    That just couldn't be all, could it?  What about terminal types not
   273    supporting operations on sub-windows of the screen (a.k.a. "TTY" or
   274    "text-mode terminals")?  To update the display on such a terminal,
   275    window-based glyph matrices are not well suited.  To be able to
   276    reuse part of the display (scrolling lines up and down), we must
   277    instead have a view of the whole screen.  This is what `frame
   278    matrices' are for.  They are a trick.
   279 
   280    Frames on text terminals have a glyph pool.  Windows on such a
   281    frame sub-allocate their glyph memory from their frame's glyph
   282    pool.  The frame itself is given its own glyph matrices.  By
   283    coincidence---or maybe something else---rows in window glyph
   284    matrices are slices of corresponding rows in frame matrices.  Thus
   285    writing to window matrices implicitly updates a frame matrix which
   286    provides us with the view of the whole screen that we originally
   287    wanted to have without having to move many bytes around.  Then
   288    updating all the visible windows on text-terminal frames is done by
   289    using the frame matrices, which allows frame-global optimization of
   290    what is actually written to the glass.
   291 
   292    Frame matrices don't have marginal areas, only a text area.  That
   293    is, the entire row of glyphs that spans the width of a text-mode
   294    frame is treated as a single large "text area" for the purposes of
   295    manipulating and updating a frame glyph matrix.
   296 
   297    To be honest, there is a little bit more done for frame matrices,
   298    but not much more.  If you plan to extend that code, take a look at
   299    dispnew.c.  The function build_frame_matrix is a good starting
   300    point.
   301 
   302    Simulating display.
   303 
   304    Some of Emacs commands and functions need to take display layout
   305    into consideration.  For example, C-n moves to the next screen
   306    line, but to implement that, Emacs needs to find the buffer
   307    position which is directly below the cursor position on display.
   308    This is not trivial when buffer display includes variable-size
   309    elements such as different fonts, tall images, etc.
   310 
   311    To solve this problem, the display engine implements several
   312    functions that can move through buffer text in the same manner as
   313    `display_line' and `display_string' do, but without producing any
   314    glyphs for the glyph matrices.  The workhorse of this is
   315    `move_it_in_display_line_to'.  Its code and logic are very similar
   316    to `display_line', but it differs in two important aspects: it
   317    doesn't produce glyphs for any glyph matrix, and it returns a
   318    status telling the caller how it ended the iteration: whether it
   319    reached the required position, hit the end of line, arrived at the
   320    window edge without exhausting the buffer's line, etc.  Since the
   321    glyphs are not produced, the layout information available to the
   322    callers of this function is what is recorded in `struct it' by the
   323    iteration process.
   324 
   325    Several higher-level functions call `move_it_in_display_line_to' to
   326    perform more complex tasks: `move_it_by_lines' can move N lines up
   327    or down from a given buffer position and `move_it_to' can move to a
   328    given buffer position or to a given X or Y pixel coordinate.
   329 
   330    These functions are called by the display engine itself as well,
   331    when it needs to make layout decisions before producing the glyphs.
   332    For example, one of the first things to decide when redisplaying a
   333    window is where to put the `window-start' position; if the window
   334    is to be recentered (the default), Emacs makes that decision by
   335    starting from the position of point, then moving up the number of
   336    lines corresponding to half the window height using
   337    `move_it_by_lines'.
   338 
   339    Bidirectional display.
   340 
   341    Bidirectional display adds quite some hair to this already complex
   342    design.  The good news are that a large portion of that hairy stuff
   343    is hidden in bidi.c behind only 3 interfaces.  bidi.c implements a
   344    reordering engine which is called by `set_iterator_to_next' and
   345    returns the next character to display in the visual order.  See
   346    commentary on bidi.c for more details.  As far as redisplay is
   347    concerned, the effect of calling `bidi_move_to_visually_next', the
   348    main interface of the reordering engine, is that the iterator gets
   349    magically placed on the buffer or string position that is to be
   350    displayed next in the visual order.  In other words, a linear
   351    iteration through the buffer/string is replaced with a non-linear
   352    one.  All the rest of the redisplay is oblivious to the bidi
   353    reordering.
   354 
   355    Well, almost oblivious---there are still complications, most of
   356    them due to the fact that buffer and string positions no longer
   357    change monotonously with glyph indices in a glyph row.  Moreover,
   358    for continued lines, the buffer positions may not even be
   359    monotonously changing with vertical positions.  Also, accounting
   360    for face changes, overlays, etc. becomes more complex because
   361    non-linear iteration could potentially skip many positions with
   362    such changes, and then cross them again on the way back (see
   363    `handle_stop_backwards')...
   364 
   365    One other prominent effect of bidirectional display is that some
   366    paragraphs of text need to be displayed starting at the right
   367    margin of the window---the so-called right-to-left, or R2L
   368    paragraphs.  R2L paragraphs are displayed with R2L glyph rows,
   369    which have their `reversed_p' flag set.  The bidi reordering engine
   370    produces characters in such rows starting from the character which
   371    should be the rightmost on display.  `PRODUCE_GLYPHS' then reverses
   372    the order, when it fills up the glyph row whose `reversed_p' flag
   373    is set, by prepending each new glyph to what is already there,
   374    instead of appending it.  When the glyph row is complete, the
   375    function `extend_face_to_end_of_line' fills the empty space to the
   376    left of the leftmost character with special glyphs, which will
   377    display as, well, empty.  On text terminals, these special glyphs
   378    are simply blank characters.  On graphics terminals, there's a
   379    single stretch glyph of a suitably computed width.  Both the blanks
   380    and the stretch glyph are given the face of the background of the
   381    line.  This way, the terminal-specific back-end can still draw the
   382    glyphs left to right, even for R2L lines.
   383 
   384    Bidirectional display and character compositions.
   385 
   386    Some scripts cannot be displayed by drawing each character
   387    individually, because adjacent characters change each other's shape
   388    on display.  For example, Arabic and Indic scripts belong to this
   389    category.
   390 
   391    Emacs display supports this by providing "character compositions",
   392    most of which is implemented in composite.c.  During the buffer
   393    scan that delivers characters to `PRODUCE_GLYPHS', if the next
   394    character to be delivered is a composed character, the iteration
   395    calls `composition_reseat_it' and `next_element_from_composition'.
   396    If they succeed to compose the character with one or more of the
   397    following characters, the whole sequence of characters that were
   398    composed is recorded in the `struct composition_it' object that is
   399    part of the buffer iterator.  The composed sequence could produce
   400    one or more font glyphs (called "grapheme clusters") on the screen.
   401    Each of these grapheme clusters is then delivered to
   402    `PRODUCE_GLYPHS' in the direction corresponding to the current bidi
   403    scan direction (recorded in the `scan_dir' member of the `struct
   404    bidi_it' object that is part of the iterator).  In particular, if
   405    the bidi iterator currently scans the buffer backwards, the
   406    grapheme clusters are delivered back to front.  This reorders the
   407    grapheme clusters as appropriate for the current bidi context.
   408    Note that this means that the grapheme clusters are always stored
   409    in the `LGSTRING' object (see composite.c) in the logical order.
   410 
   411    Moving an iterator in bidirectional text
   412    without producing glyphs.
   413 
   414    Note one important detail mentioned above: that the bidi reordering
   415    engine, driven by the iterator, produces characters in R2L rows
   416    starting at the character that will be the rightmost on display.
   417    As far as the iterator is concerned, the geometry of such rows is
   418    still left to right, i.e. the iterator "thinks" the first character
   419    is at the leftmost pixel position.  The iterator does not know that
   420    `PRODUCE_GLYPHS' reverses the order of the glyphs that the iterator
   421    delivers.  This is important when functions from the `move_it_*'
   422    family are used to get to certain screen position or to match
   423    screen coordinates with buffer coordinates: these functions use the
   424    iterator geometry, which is left to right even in R2L paragraphs.
   425    This works well with most callers of `move_it_*', because they need
   426    to get to a specific column, and columns are still numbered in the
   427    reading order, i.e. the rightmost character in a R2L paragraph is
   428    still column zero.  But some callers do not get well with this; a
   429    notable example is mouse clicks that need to find the character
   430    that corresponds to certain pixel coordinates.  See
   431    `buffer_posn_from_coords' in dispnew.c for how this is handled.  */
   432 
   433 #include <config.h>
   434 #include <stdlib.h>
   435 #include <limits.h>
   436 #include <math.h>
   437 
   438 #include "lisp.h"
   439 #include "atimer.h"
   440 #include "composite.h"
   441 #include "keyboard.h"
   442 #include "sysstdio.h"
   443 #include "systime.h"
   444 #include "frame.h"
   445 #include "window.h"
   446 #include "termchar.h"
   447 #include "dispextern.h"
   448 #include "character.h"
   449 #include "category.h"
   450 #include "buffer.h"
   451 #include "charset.h"
   452 #include "indent.h"
   453 #include "commands.h"
   454 #include "keymap.h"
   455 #include "disptab.h"
   456 #include "termhooks.h"
   457 #include "termopts.h"
   458 #include "intervals.h"
   459 #include "coding.h"
   460 #include "region-cache.h"
   461 #include "font.h"
   462 #include "fontset.h"
   463 #include "blockinput.h"
   464 #include "xwidget.h"
   465 #ifdef HAVE_WINDOW_SYSTEM
   466 #include TERM_HEADER
   467 #endif /* HAVE_WINDOW_SYSTEM */
   468 
   469 #ifndef FRAME_OUTPUT_DATA
   470 #define FRAME_OUTPUT_DATA(f) (NULL)
   471 #endif
   472 
   473 #define DISP_INFINITY 10000000
   474 
   475 /* Holds the list (error).  */
   476 static Lisp_Object list_of_error;
   477 
   478 #ifdef HAVE_WINDOW_SYSTEM
   479 
   480 /* Test if overflow newline into fringe.  Called with iterator IT
   481    at or past right window margin, and with IT->current_x set.  */
   482 
   483 #define IT_OVERFLOW_NEWLINE_INTO_FRINGE(IT)             \
   484   (!NILP (Voverflow_newline_into_fringe)                \
   485    && FRAME_WINDOW_P ((IT)->f)                          \
   486    && ((IT)->bidi_it.paragraph_dir == R2L               \
   487        ? (WINDOW_LEFT_FRINGE_WIDTH ((IT)->w) > 0)       \
   488        : (WINDOW_RIGHT_FRINGE_WIDTH ((IT)->w) > 0))     \
   489    && (IT)->current_x == (IT)->last_visible_x)
   490 
   491 #else /* !HAVE_WINDOW_SYSTEM */
   492 #define IT_OVERFLOW_NEWLINE_INTO_FRINGE(it) false
   493 #endif /* HAVE_WINDOW_SYSTEM */
   494 
   495 /* Test if the display element loaded in IT, or the underlying buffer
   496    or string character, is a space or a TAB character.  This is used
   497    to determine where word wrapping can occur.  */
   498 
   499 #define IT_DISPLAYING_WHITESPACE(it)                                    \
   500   ((it->what == IT_CHARACTER && (it->c == ' ' || it->c == '\t'))        \
   501    || ((STRINGP (it->string)                                            \
   502         && (SREF (it->string, IT_STRING_BYTEPOS (*it)) == ' '           \
   503             || SREF (it->string, IT_STRING_BYTEPOS (*it)) == '\t'))     \
   504        || (it->s                                                        \
   505            && (it->s[IT_BYTEPOS (*it)] == ' '                           \
   506                || it->s[IT_BYTEPOS (*it)] == '\t'))                     \
   507        || (IT_BYTEPOS (*it) < ZV_BYTE                                   \
   508            && (*BYTE_POS_ADDR (IT_BYTEPOS (*it)) == ' '                 \
   509                || *BYTE_POS_ADDR (IT_BYTEPOS (*it)) == '\t'))))
   510 
   511 /* These are the category sets we use.  They are defined by
   512    kinsoku.el and characters.el.  */
   513 #define NOT_AT_EOL '<'
   514 #define NOT_AT_BOL '>'
   515 #define LINE_BREAKABLE '|'
   516 
   517 static bool
   518 it_char_has_category(struct it *it, int cat)
   519 {
   520   int ch = 0;
   521   if (it->what == IT_CHARACTER)
   522     ch = it->c;
   523   else if (STRINGP (it->string))
   524     ch = SREF (it->string, IT_STRING_BYTEPOS (*it));
   525   else if (it->s)
   526     ch = it->s[IT_BYTEPOS (*it)];
   527   else if (IT_BYTEPOS (*it) < ZV_BYTE)
   528     ch = *BYTE_POS_ADDR (IT_BYTEPOS (*it));
   529 
   530   if (ch == 0)
   531     return false;
   532   else
   533     return CHAR_HAS_CATEGORY (ch, cat);
   534 }
   535 
   536 /* Return true if the current character allows wrapping before it.   */
   537 static bool
   538 char_can_wrap_before (struct it *it)
   539 {
   540   if (!word_wrap_by_category)
   541     return !IT_DISPLAYING_WHITESPACE (it);
   542 
   543   /* For CJK (LTR) text in RTL paragraph, EOL and BOL are flipped.
   544      Because in RTL paragraph, each glyph is prepended to the last
   545      one, effectively drawing right to left.  */
   546   int not_at_bol;
   547   if (it->glyph_row && it->glyph_row->reversed_p)
   548     not_at_bol = NOT_AT_EOL;
   549   else
   550     not_at_bol = NOT_AT_BOL;
   551   /* You cannot wrap before a space or tab because that way you'll
   552      have space and tab at the beginning of next line.  */
   553   return (!IT_DISPLAYING_WHITESPACE (it)
   554           /* Can be at BOL.  */
   555           && !it_char_has_category (it, not_at_bol));
   556 }
   557 
   558 /* Return true if the current character allows wrapping after it.   */
   559 static bool
   560 char_can_wrap_after (struct it *it)
   561 {
   562   if (!word_wrap_by_category)
   563     return IT_DISPLAYING_WHITESPACE (it);
   564 
   565   /* For CJK (LTR) text in RTL paragraph, EOL and BOL are flipped.
   566      Because in RTL paragraph, each glyph is prepended to the last
   567      one, effectively drawing right to left.  */
   568   int not_at_eol;
   569   if (it->glyph_row && it->glyph_row->reversed_p)
   570     not_at_eol = NOT_AT_BOL;
   571   else
   572     not_at_eol = NOT_AT_EOL;
   573 
   574   return (IT_DISPLAYING_WHITESPACE (it)
   575           /* Can break after && can be at EOL.  */
   576           || (it_char_has_category (it, LINE_BREAKABLE)
   577               && !it_char_has_category (it, not_at_eol)));
   578 }
   579 
   580 #undef IT_DISPLAYING_WHITESPACE
   581 #undef NOT_AT_EOL
   582 #undef NOT_AT_BOL
   583 #undef LINE_BREAKABLE
   584 
   585 /* If all the conditions needed to print the fill column indicator are
   586    met, return the (nonnegative) column number, else return a negative
   587    value.  */
   588 static int
   589 fill_column_indicator_column (struct it *it, int char_width)
   590 {
   591   if (display_fill_column_indicator
   592       && !it->w->pseudo_window_p
   593       && it->continuation_lines_width == 0
   594       && CHARACTERP (Vdisplay_fill_column_indicator_character))
   595     {
   596       Lisp_Object col = (EQ (Vdisplay_fill_column_indicator_column, Qt)
   597                          ? BVAR (current_buffer, fill_column)
   598                          : Vdisplay_fill_column_indicator_column);
   599 
   600       /* The stretch width needs to consider the latter
   601          added glyph in append_space_for_newline.  */
   602       if (RANGED_FIXNUMP (0, col, INT_MAX))
   603         {
   604           int icol = XFIXNUM (col);
   605           if (!ckd_mul (&icol, icol, char_width)
   606               && !ckd_add (&icol, icol, it->lnum_pixel_width))
   607             return icol;
   608         }
   609     }
   610   return -1;
   611 }
   612 
   613 /* True means print newline to stdout before next mini-buffer message.  */
   614 
   615 bool noninteractive_need_newline;
   616 
   617 /* True means print newline to message log before next message.  */
   618 
   619 static bool message_log_need_newline;
   620 
   621 /* Three markers that message_dolog uses.
   622    It could allocate them itself, but that causes trouble
   623    in handling memory-full errors.  */
   624 static Lisp_Object message_dolog_marker1;
   625 static Lisp_Object message_dolog_marker2;
   626 static Lisp_Object message_dolog_marker3;
   627 
   628 /* The buffer position of the first character appearing entirely or
   629    partially on the line of the selected window which contains the
   630    cursor; <= 0 if not known.  Set by set_cursor_from_row, used for
   631    redisplay optimization in redisplay_internal.  */
   632 
   633 static struct text_pos this_line_start_pos;
   634 
   635 /* Number of characters past the end of the line above, including the
   636    terminating newline.  */
   637 
   638 static struct text_pos this_line_end_pos;
   639 
   640 /* The vertical positions and the height of this line.  */
   641 
   642 static int this_line_vpos;
   643 static int this_line_y;
   644 static int this_line_pixel_height;
   645 
   646 /* X position at which this display line starts.  Usually zero;
   647    negative if first character is partially visible.  */
   648 
   649 static int this_line_start_x;
   650 
   651 /* The smallest character position seen by move_it_* functions as they
   652    move across display lines.  Used to set MATRIX_ROW_START_CHARPOS of
   653    hscrolled lines, see display_line.  */
   654 
   655 static struct text_pos this_line_min_pos;
   656 
   657 /* Buffer that this_line_.* variables are referring to.  */
   658 
   659 static struct buffer *this_line_buffer;
   660 
   661 /* True if an overlay arrow has been displayed in this window.  */
   662 
   663 static bool overlay_arrow_seen;
   664 
   665 /* Vector containing glyphs for an ellipsis `...'.  */
   666 
   667 static Lisp_Object default_invis_vector[3];
   668 
   669 /* This is the window where the echo area message was displayed.  It
   670    is always a mini-buffer window, but it may not be the same window
   671    currently active as a mini-buffer.  */
   672 
   673 Lisp_Object echo_area_window;
   674 
   675 /* Stack of messages, which are pushed by push_message and popped and
   676    displayed by restore_message.  */
   677 
   678 static Lisp_Object Vmessage_stack;
   679 
   680 /* True means multibyte characters were enabled when the echo area
   681    message was specified.  */
   682 
   683 static bool message_enable_multibyte;
   684 
   685 /* At each redisplay cycle, we should refresh everything there is to refresh.
   686    To do that efficiently, we use many optimizations that try to make sure we
   687    don't waste too much time updating things that haven't changed.
   688    The coarsest such optimization is that, in the most common cases, we only
   689    look at the selected-window.
   690 
   691    To know whether other windows should be considered for redisplay, we use the
   692    variable windows_or_buffers_changed: as long as it is 0, it means that we
   693    have not noticed anything that should require updating anything else than
   694    the selected-window.  If it is set to REDISPLAY_SOME, it means that since
   695    last redisplay, some changes have been made which could impact other
   696    windows.  To know which ones need redisplay, every buffer, window, and frame
   697    has a `redisplay' bit, which (if true) means that this object needs to be
   698    redisplayed.  If windows_or_buffers_changed is 0, we know there's no point
   699    looking for those `redisplay' bits (actually, there might be some such bits
   700    set, but then only on objects which aren't displayed anyway).
   701 
   702    OTOH if it's non-zero we will have to loop through all windows and then
   703    check the `redisplay' bit of the corresponding window, frame, and buffer, in
   704    order to decide whether that window needs attention or not.  Note that we
   705    can't just look at the frame's redisplay bit to decide that the whole frame
   706    can be skipped, since even if the frame's redisplay bit is unset, some of
   707    its windows's redisplay bits may be set.
   708 
   709    Mostly for historical reasons, windows_or_buffers_changed can also take
   710    other non-zero values.  In that case, the precise value doesn't matter (it
   711    encodes the cause of the setting but is only used for debugging purposes),
   712    and what it means is that we shouldn't pay attention to any `redisplay' bits
   713    and we should simply try and redisplay every window out there.  */
   714 
   715 int windows_or_buffers_changed;
   716 
   717 /* Nonzero if we should redraw the mode lines on the next redisplay.
   718    Similarly to `windows_or_buffers_changed', if it has value REDISPLAY_SOME,
   719    then only redisplay the mode lines in those buffers/windows/frames where the
   720    `redisplay' bit has been set.
   721    For any other value, redisplay all mode lines (the number used is then only
   722    used to track down the cause for this full-redisplay).
   723 
   724    Since the frame title uses the same %-constructs as the mode line
   725    (except %c, %C, and %l), if this variable is non-zero, we also consider
   726    redisplaying the title of each frame, see gui_consider_frame_title.
   727 
   728    The `redisplay' bits are the same as those used for
   729    windows_or_buffers_changed, and setting windows_or_buffers_changed also
   730    causes recomputation of the mode lines of all those windows.  IOW this
   731    variable only has an effect if windows_or_buffers_changed is zero, in which
   732    case we should only need to redisplay the mode-line of those objects with
   733    a `redisplay' bit set but not the window's text content (tho we may still
   734    need to refresh the text content of the selected-window).  */
   735 
   736 int update_mode_lines;
   737 
   738 /* True after display_mode_line if %l was used and it displayed a
   739    line number.  */
   740 
   741 static bool line_number_displayed;
   742 
   743 /* Current, index 0, and last displayed echo area message.  Either
   744    buffers from echo_buffers, or nil to indicate no message.  */
   745 
   746 Lisp_Object echo_area_buffer[2];
   747 
   748 /* The buffers referenced from echo_area_buffer.  */
   749 
   750 static Lisp_Object echo_buffer[2];
   751 
   752 /* A vector saved used in with_area_buffer to reduce consing.  */
   753 
   754 static Lisp_Object Vwith_echo_area_save_vector;
   755 
   756 /* True means display_echo_area should display the last echo area
   757    message again.  Set by redisplay_preserve_echo_area.  */
   758 
   759 static bool display_last_displayed_message_p;
   760 
   761 /* True if echo area is being used by print; false if being used by
   762    message.  */
   763 
   764 static bool message_buf_print;
   765 
   766 /* Set to true in clear_message to make redisplay_internal aware
   767    of an emptied echo area.  */
   768 
   769 static bool message_cleared_p;
   770 
   771 /* A scratch glyph row with contents used for generating truncation
   772    glyphs and overlay-arrow glyphs.  */
   773 
   774 #define MAX_SCRATCH_GLYPHS 100
   775 static struct glyph_row scratch_glyph_row;
   776 static struct glyph scratch_glyphs[MAX_SCRATCH_GLYPHS];
   777 
   778 /* Ascent and height of the last line processed by move_it_to.  */
   779 
   780 static int last_height;
   781 
   782 /* True if there's a help-echo in the echo area.  */
   783 
   784 bool help_echo_showing_p;
   785 
   786 /* The maximum distance to look ahead for text properties.  Values
   787    that are too small let us call compute_char_face and similar
   788    functions too often which is expensive.  Values that are too large
   789    let us call compute_char_face and alike too often because we
   790    might not be interested in text properties that far away.  */
   791 
   792 #define TEXT_PROP_DISTANCE_LIMIT 100
   793 
   794 /* SAVE_IT and RESTORE_IT are called when we save a snapshot of the
   795    iterator state and later restore it.  This is needed because the
   796    bidi iterator on bidi.c keeps a stacked cache of its states, which
   797    is really a singleton.  When we use scratch iterator objects to
   798    move around the buffer, we can cause the bidi cache to be pushed or
   799    popped, and therefore we need to restore the cache state when we
   800    return to the original iterator.  */
   801 #define SAVE_IT(ITCOPY, ITORIG, CACHE)          \
   802   do {                                          \
   803     if (CACHE)                                  \
   804       bidi_unshelve_cache (CACHE, true);        \
   805     ITCOPY = ITORIG;                            \
   806     CACHE = bidi_shelve_cache ();               \
   807   } while (false)
   808 
   809 #define RESTORE_IT(pITORIG, pITCOPY, CACHE)     \
   810   do {                                          \
   811     if (pITORIG != pITCOPY)                     \
   812       *(pITORIG) = *(pITCOPY);                  \
   813     bidi_unshelve_cache (CACHE, false);         \
   814     CACHE = NULL;                               \
   815   } while (false)
   816 
   817 /* Functions to mark elements as needing redisplay.  */
   818 enum { REDISPLAY_SOME = 2};     /* Arbitrary choice.  */
   819 
   820 static bool calc_pixel_width_or_height (double *, struct it *, Lisp_Object,
   821                                         struct font *, bool, int *);
   822 
   823 void
   824 redisplay_other_windows (void)
   825 {
   826   if (!windows_or_buffers_changed)
   827     windows_or_buffers_changed = REDISPLAY_SOME;
   828 }
   829 
   830 void
   831 wset_redisplay (struct window *w)
   832 {
   833   /* Beware: selected_window can be nil during early stages.  */
   834   if (!BASE_EQ (make_lisp_ptr (w, Lisp_Vectorlike), selected_window))
   835     redisplay_other_windows ();
   836   w->redisplay = true;
   837 }
   838 
   839 void
   840 fset_redisplay (struct frame *f)
   841 {
   842   redisplay_other_windows ();
   843   f->redisplay = true;
   844 }
   845 
   846 void
   847 bset_redisplay (struct buffer *b)
   848 {
   849   int count = buffer_window_count (b);
   850   if (count > 0)
   851     {
   852       /* ... it's visible in other window than selected,  */
   853       if (count > 1 || b != XBUFFER (XWINDOW (selected_window)->contents))
   854         redisplay_other_windows ();
   855       /* Even if we don't set windows_or_buffers_changed, do set `redisplay'
   856          so that if we later set windows_or_buffers_changed, this buffer will
   857          not be omitted.  */
   858       b->text->redisplay = true;
   859     }
   860 }
   861 
   862 void
   863 bset_update_mode_line (struct buffer *b)
   864 {
   865   if (!update_mode_lines)
   866     update_mode_lines = REDISPLAY_SOME;
   867   b->text->redisplay = true;
   868 }
   869 
   870 void
   871 wset_update_mode_line (struct window *w)
   872 {
   873   w->update_mode_line = true;
   874   /* When a window's mode line needs to be updated, the window's frame's
   875      title may also need to be updated, but we don't need to worry about it
   876      here.  Instead, `gui_consider_frame_title' is automatically called
   877      whenever w->update_mode_line is set for that frame's selected window.
   878      But for this to work reliably, we have to make sure the window
   879      is considered, so we have to mark it for redisplay.  */
   880   wset_redisplay (w);
   881 }
   882 
   883 DEFUN ("set-buffer-redisplay", Fset_buffer_redisplay,
   884        Sset_buffer_redisplay, 4, 4, 0,
   885        doc: /* Mark the current buffer for redisplay.
   886 This function may be passed to `add-variable-watcher'.  */)
   887   (Lisp_Object symbol, Lisp_Object newval, Lisp_Object op, Lisp_Object where)
   888 {
   889   bset_update_mode_line (current_buffer);
   890   current_buffer->prevent_redisplay_optimizations_p = true;
   891   return Qnil;
   892 }
   893 
   894 /* redisplay_trace is for displaying traces of redisplay.
   895    If Emacs was compiled with GLYPH_DEBUG defined, the variable
   896    trace_redisplay_p can be set to a non-zero value in debugging
   897    sessions to activate traces.  */
   898 #ifdef GLYPH_DEBUG
   899 extern bool trace_redisplay_p EXTERNALLY_VISIBLE;
   900 bool trace_redisplay_p;
   901 #else
   902 enum { trace_redisplay_p = false };
   903 #endif
   904 static void ATTRIBUTE_FORMAT_PRINTF (1, 2)
   905 redisplay_trace (char const *fmt, ...)
   906 {
   907   if (trace_redisplay_p)
   908     {
   909       va_list ap;
   910       va_start (ap, fmt);
   911       vprintf (fmt, ap);
   912       va_end (ap);
   913     }
   914 }
   915 
   916 #ifdef DEBUG_TRACE_MOVE
   917 extern bool trace_move EXTERNALLY_VISIBLE;
   918 bool trace_move;
   919 #else
   920 enum { trace_move = false };
   921 #endif
   922 static void ATTRIBUTE_FORMAT_PRINTF (1, 2)
   923 move_trace (char const *fmt, ...)
   924 {
   925   if (trace_move)
   926     {
   927       va_list ap;
   928       va_start (ap, fmt);
   929       vprintf (fmt, ap);
   930       va_end (ap);
   931     }
   932 }
   933 
   934 /* Buffer being redisplayed -- for redisplay_window_error.  */
   935 
   936 static struct buffer *displayed_buffer;
   937 
   938 /* Value returned from text property handlers (see below).  */
   939 
   940 enum prop_handled
   941 {
   942   HANDLED_NORMALLY,
   943   HANDLED_RECOMPUTE_PROPS,
   944   HANDLED_OVERLAY_STRING_CONSUMED,
   945   HANDLED_RETURN
   946 };
   947 
   948 /* A description of text properties that redisplay is interested
   949    in.  */
   950 
   951 struct props
   952 {
   953   /* The symbol index of the name of the property.  */
   954   short name;
   955 
   956   /* A unique index for the property.  */
   957   enum prop_idx idx;
   958 
   959   /* A handler function called to set up iterator IT from the property
   960      at IT's current position.  Value is used to steer handle_stop.  */
   961   enum prop_handled (*handler) (struct it *it);
   962 };
   963 
   964 static enum prop_handled handle_face_prop (struct it *);
   965 static enum prop_handled handle_invisible_prop (struct it *);
   966 static enum prop_handled handle_display_prop (struct it *);
   967 static enum prop_handled handle_composition_prop (struct it *);
   968 static enum prop_handled handle_overlay_change (struct it *);
   969 static enum prop_handled handle_fontified_prop (struct it *);
   970 
   971 /* Properties handled by iterators.  */
   972 
   973 static struct props it_props[] =
   974 {
   975   {SYMBOL_INDEX (Qfontified),   FONTIFIED_PROP_IDX,     handle_fontified_prop},
   976   /* Handle `face' before `display' because some sub-properties of
   977      `display' need to know the face.  */
   978   {SYMBOL_INDEX (Qface),        FACE_PROP_IDX,          handle_face_prop},
   979   {SYMBOL_INDEX (Qdisplay),     DISPLAY_PROP_IDX,       handle_display_prop},
   980   {SYMBOL_INDEX (Qinvisible),   INVISIBLE_PROP_IDX,     handle_invisible_prop},
   981   {SYMBOL_INDEX (Qcomposition), COMPOSITION_PROP_IDX, handle_composition_prop},
   982   {0,                           0,                      NULL}
   983 };
   984 
   985 /* Enumeration returned by some move_it_.* functions internally.  */
   986 
   987 enum move_it_result
   988 {
   989   /* Not used.  Undefined value.  */
   990   MOVE_UNDEFINED,
   991 
   992   /* Move ended at the requested buffer position or ZV.  */
   993   MOVE_POS_MATCH_OR_ZV,
   994 
   995   /* Move ended at the requested X pixel position.  */
   996   MOVE_X_REACHED,
   997 
   998   /* Move within a line ended at the end of a line that must be
   999      continued.  */
  1000   MOVE_LINE_CONTINUED,
  1001 
  1002   /* Move within a line ended at the end of a line that would
  1003      be displayed truncated.  */
  1004   MOVE_LINE_TRUNCATED,
  1005 
  1006   /* Move within a line ended at a line end.  */
  1007   MOVE_NEWLINE_OR_CR
  1008 };
  1009 
  1010 /* This counter is used to clear the face cache every once in a while
  1011    in redisplay_internal.  It is incremented for each redisplay.
  1012    Every CLEAR_FACE_CACHE_COUNT full redisplays, the face cache is
  1013    cleared.  */
  1014 
  1015 #define CLEAR_FACE_CACHE_COUNT  500
  1016 static int clear_face_cache_count;
  1017 
  1018 /* Similarly for the image cache.  */
  1019 
  1020 #ifdef HAVE_WINDOW_SYSTEM
  1021 #define CLEAR_IMAGE_CACHE_COUNT 101
  1022 static int clear_image_cache_count;
  1023 
  1024 /* Null glyph slice */
  1025 static struct glyph_slice null_glyph_slice = { 0, 0, 0, 0 };
  1026 #endif
  1027 
  1028 /* True while redisplay_internal is in progress.  */
  1029 
  1030 bool redisplaying_p;
  1031 
  1032 /* True while some display-engine code is working on layout of some
  1033    window.
  1034 
  1035    WARNING: Use sparingly, preferably only in top level of commands
  1036    and important functions, because using it in nested calls might
  1037    reset the flag when the inner call returns, behind the back of
  1038    the callers.  */
  1039 bool display_working_on_window_p;
  1040 
  1041 /* If a string, XTread_socket generates an event to display that string.
  1042    (The display is done in read_char.)  */
  1043 
  1044 Lisp_Object help_echo_string;
  1045 Lisp_Object help_echo_window;
  1046 Lisp_Object help_echo_object;
  1047 ptrdiff_t help_echo_pos;
  1048 
  1049 /* Temporary variable for XTread_socket.  */
  1050 
  1051 Lisp_Object previous_help_echo_string;
  1052 
  1053 /* Platform-independent portion of hourglass implementation.  */
  1054 
  1055 #ifdef HAVE_WINDOW_SYSTEM
  1056 
  1057 /* True means an hourglass cursor is currently shown.  */
  1058 static bool hourglass_shown_p;
  1059 
  1060 /* If non-null, an asynchronous timer that, when it expires, displays
  1061    an hourglass cursor on all frames.  */
  1062 static struct atimer *hourglass_atimer;
  1063 
  1064 #endif /* HAVE_WINDOW_SYSTEM */
  1065 
  1066 /* Default number of seconds to wait before displaying an hourglass
  1067    cursor.  */
  1068 #define DEFAULT_HOURGLASS_DELAY 1
  1069 
  1070 #ifdef HAVE_WINDOW_SYSTEM
  1071 
  1072 /* Default pixel width of `thin-space' display method.  */
  1073 #define THIN_SPACE_WIDTH 1
  1074 
  1075 #endif /* HAVE_WINDOW_SYSTEM */
  1076 
  1077 /* Function prototypes.  */
  1078 
  1079 static void setup_for_ellipsis (struct it *, int);
  1080 static void set_iterator_to_next (struct it *, bool);
  1081 static void mark_window_display_accurate_1 (struct window *, bool);
  1082 static bool row_for_charpos_p (struct glyph_row *, ptrdiff_t);
  1083 static bool cursor_row_p (struct glyph_row *);
  1084 static int redisplay_mode_lines (Lisp_Object, bool);
  1085 
  1086 static void handle_line_prefix (struct it *);
  1087 
  1088 static void handle_stop_backwards (struct it *, ptrdiff_t);
  1089 static void unwind_with_echo_area_buffer (Lisp_Object);
  1090 static Lisp_Object with_echo_area_buffer_unwind_data (struct window *);
  1091 static bool current_message_1 (void *, Lisp_Object);
  1092 static bool truncate_message_1 (void *, Lisp_Object);
  1093 static void set_message (Lisp_Object);
  1094 static bool set_message_1 (void *, Lisp_Object);
  1095 static bool display_echo_area_1 (void *, Lisp_Object);
  1096 static bool resize_mini_window_1 (void *, Lisp_Object);
  1097 static void unwind_redisplay (void);
  1098 static void extend_face_to_end_of_line (struct it *);
  1099 static intmax_t message_log_check_duplicate (ptrdiff_t, ptrdiff_t);
  1100 static void push_it (struct it *, struct text_pos *);
  1101 static void iterate_out_of_display_property (struct it *);
  1102 static void pop_it (struct it *);
  1103 static void redisplay_internal (void);
  1104 static void echo_area_display (bool);
  1105 static void block_buffer_flips (void);
  1106 static void unblock_buffer_flips (void);
  1107 static void redisplay_windows (Lisp_Object);
  1108 static void redisplay_window (Lisp_Object, bool);
  1109 static Lisp_Object redisplay_window_error (Lisp_Object);
  1110 static Lisp_Object redisplay_window_0 (Lisp_Object);
  1111 static Lisp_Object redisplay_window_1 (Lisp_Object);
  1112 static bool set_cursor_from_row (struct window *, struct glyph_row *,
  1113                                  struct glyph_matrix *, ptrdiff_t, ptrdiff_t,
  1114                                  int, int);
  1115 static bool cursor_row_fully_visible_p (struct window *, bool, bool, bool);
  1116 static bool update_menu_bar (struct frame *, bool, bool);
  1117 static bool try_window_reusing_current_matrix (struct window *);
  1118 static int try_window_id (struct window *);
  1119 static void maybe_produce_line_number (struct it *);
  1120 static bool should_produce_line_number (struct it *);
  1121 static bool display_line (struct it *, int);
  1122 static int display_mode_lines (struct window *);
  1123 static int display_mode_line (struct window *, enum face_id, Lisp_Object);
  1124 static int display_mode_element (struct it *, int, int, int, Lisp_Object,
  1125                                  Lisp_Object, bool);
  1126 static int store_mode_line_string (const char *, Lisp_Object, bool, int, int,
  1127                                    Lisp_Object);
  1128 static const char *decode_mode_spec (struct window *, int, int, Lisp_Object *);
  1129 static void display_menu_bar (struct window *);
  1130 static void display_tab_bar (struct window *);
  1131 static void update_tab_bar (struct frame *, bool);
  1132 static ptrdiff_t display_count_lines (ptrdiff_t, ptrdiff_t, ptrdiff_t,
  1133                                       ptrdiff_t *);
  1134 static void pint2str (register char *, register int, register ptrdiff_t);
  1135 
  1136 static int display_string (const char *, Lisp_Object, Lisp_Object,
  1137                            ptrdiff_t, ptrdiff_t, struct it *, int, int, int,
  1138                            int);
  1139 static void compute_line_metrics (struct it *);
  1140 static bool get_overlay_strings (struct it *, ptrdiff_t);
  1141 static bool get_overlay_strings_1 (struct it *, ptrdiff_t, bool);
  1142 static void next_overlay_string (struct it *);
  1143 static void reseat (struct it *, struct text_pos, bool);
  1144 static void reseat_1 (struct it *, struct text_pos, bool);
  1145 static bool next_element_from_display_vector (struct it *);
  1146 static bool next_element_from_string (struct it *);
  1147 static bool next_element_from_c_string (struct it *);
  1148 static bool next_element_from_buffer (struct it *);
  1149 static bool next_element_from_composition (struct it *);
  1150 static bool next_element_from_image (struct it *);
  1151 static bool next_element_from_stretch (struct it *);
  1152 static bool next_element_from_xwidget (struct it *);
  1153 static void load_overlay_strings (struct it *, ptrdiff_t);
  1154 static bool get_next_display_element (struct it *);
  1155 static enum move_it_result
  1156        move_it_in_display_line_to (struct it *, ptrdiff_t, int,
  1157                                    enum move_operation_enum);
  1158 static void get_visually_first_element (struct it *);
  1159 static void compute_stop_pos (struct it *);
  1160 static int face_before_or_after_it_pos (struct it *, bool);
  1161 static int handle_display_spec (struct it *, Lisp_Object, Lisp_Object,
  1162                                 Lisp_Object, struct text_pos *, ptrdiff_t, bool);
  1163 static int handle_single_display_spec (struct it *, Lisp_Object, Lisp_Object,
  1164                                        Lisp_Object, struct text_pos *,
  1165                                        ptrdiff_t, int, bool, bool);
  1166 static int underlying_face_id (const struct it *);
  1167 
  1168 #define face_before_it_pos(IT) face_before_or_after_it_pos (IT, true)
  1169 #define face_after_it_pos(IT)  face_before_or_after_it_pos (IT, false)
  1170 
  1171 #ifdef HAVE_WINDOW_SYSTEM
  1172 
  1173 static void update_tool_bar (struct frame *, bool);
  1174 static void gui_draw_bottom_divider (struct window *w);
  1175 static void notice_overwritten_cursor (struct window *,
  1176                                        enum glyph_row_area,
  1177                                        int, int, int, int);
  1178 static int  normal_char_height (struct font *, int);
  1179 static void normal_char_ascent_descent (struct font *, int, int *, int *);
  1180 
  1181 static void append_stretch_glyph (struct it *, Lisp_Object,
  1182                                   int, int, int);
  1183 
  1184 static Lisp_Object get_it_property (struct it *, Lisp_Object);
  1185 static Lisp_Object calc_line_height_property (struct it *, Lisp_Object,
  1186                                               struct font *, int, bool);
  1187 static int adjust_glyph_width_for_mouse_face (struct glyph *,
  1188                                               struct glyph_row *,
  1189                                               struct window *, struct face *,
  1190                                               struct face *);
  1191 static void get_cursor_offset_for_mouse_face (struct window *w,
  1192                                               struct glyph_row *row,
  1193                                               int *offset);
  1194 #endif /* HAVE_WINDOW_SYSTEM */
  1195 
  1196 static void produce_special_glyphs (struct it *, enum display_element_type);
  1197 static void pad_mode_line (struct it *, bool);
  1198 static void show_mouse_face (Mouse_HLInfo *, enum draw_glyphs_face);
  1199 static bool coords_in_mouse_face_p (struct window *, int, int);
  1200 static void reset_box_start_end_flags (struct it *);
  1201 
  1202 
  1203 
  1204 /***********************************************************************
  1205                       Window display dimensions
  1206  ***********************************************************************/
  1207 
  1208 /* Return the bottom boundary y-position for text lines in window W.
  1209    This is the first y position at which a line cannot start.
  1210    It is relative to the top of the window.
  1211 
  1212    This is the height of W minus the height of a mode line, if any.  */
  1213 
  1214 int
  1215 window_text_bottom_y (struct window *w)
  1216 {
  1217   int height = WINDOW_PIXEL_HEIGHT (w);
  1218 
  1219   height -= WINDOW_BOTTOM_DIVIDER_WIDTH (w);
  1220 
  1221   if (window_wants_mode_line (w))
  1222     height -= CURRENT_MODE_LINE_HEIGHT (w);
  1223 
  1224   height -= WINDOW_SCROLL_BAR_AREA_HEIGHT (w);
  1225 
  1226   return height;
  1227 }
  1228 
  1229 /* Return the pixel width of display area AREA of window W.
  1230    ANY_AREA means return the total width of W, not including
  1231    fringes to the left and right of the window.  */
  1232 
  1233 int
  1234 window_box_width (struct window *w, enum glyph_row_area area)
  1235 {
  1236   int width = w->pixel_width;
  1237 
  1238   if (!w->pseudo_window_p)
  1239     {
  1240       width -= WINDOW_SCROLL_BAR_AREA_WIDTH (w);
  1241       width -= WINDOW_RIGHT_DIVIDER_WIDTH (w);
  1242 
  1243       if (area == TEXT_AREA)
  1244         width -= (WINDOW_MARGINS_WIDTH (w)
  1245                    + WINDOW_FRINGES_WIDTH (w));
  1246       else if (area == LEFT_MARGIN_AREA)
  1247         width = WINDOW_LEFT_MARGIN_WIDTH (w);
  1248       else if (area == RIGHT_MARGIN_AREA)
  1249         width = WINDOW_RIGHT_MARGIN_WIDTH (w);
  1250     }
  1251 
  1252   /* With wide margins, fringes, etc. we might end up with a negative
  1253      width, correct that here.  */
  1254   return max (0, width);
  1255 }
  1256 
  1257 
  1258 /* Return the pixel height of the display area of window W, not
  1259    including mode lines of W, if any.  */
  1260 
  1261 int
  1262 window_box_height (struct window *w)
  1263 {
  1264   struct frame *f = XFRAME (w->frame);
  1265   int height = WINDOW_PIXEL_HEIGHT (w);
  1266 
  1267   eassert (height >= 0);
  1268 
  1269   height -= WINDOW_BOTTOM_DIVIDER_WIDTH (w);
  1270   height -= WINDOW_SCROLL_BAR_AREA_HEIGHT (w);
  1271 
  1272   /* Note: the code below that determines the mode-line/header-line/tab-line
  1273      height is essentially the same as that contained in the macro
  1274      CURRENT_{MODE,HEADER,TAB}_LINE_HEIGHT, except that it checks whether
  1275      the appropriate glyph row has its `mode_line_p' flag set, and if
  1276      it doesn't, uses estimate_mode_line_height instead.  */
  1277 
  1278   if (window_wants_mode_line (w))
  1279     {
  1280       if (w->mode_line_height >= 0)
  1281         height -= w->mode_line_height;
  1282       else
  1283         {
  1284           struct glyph_row *ml_row
  1285             = (w->current_matrix && w->current_matrix->rows
  1286                ? MATRIX_MODE_LINE_ROW (w->current_matrix)
  1287                : 0);
  1288           if (ml_row && ml_row->mode_line_p)
  1289             height -= ml_row->height;
  1290           else
  1291             height -= estimate_mode_line_height
  1292               (f, CURRENT_MODE_LINE_ACTIVE_FACE_ID (w));
  1293         }
  1294     }
  1295 
  1296   if (window_wants_tab_line (w))
  1297     {
  1298       if (w->tab_line_height >= 0)
  1299         height -= w->tab_line_height;
  1300       else
  1301         {
  1302           struct glyph_row *tl_row
  1303             = (w->current_matrix && w->current_matrix->rows
  1304                ? MATRIX_TAB_LINE_ROW (w->current_matrix)
  1305                : 0);
  1306           if (tl_row && tl_row->mode_line_p)
  1307             height -= tl_row->height;
  1308           else
  1309             height -= estimate_mode_line_height (f, TAB_LINE_FACE_ID);
  1310         }
  1311     }
  1312 
  1313   if (window_wants_header_line (w))
  1314     {
  1315       if (w->header_line_height >= 0)
  1316         height -= w->header_line_height;
  1317       else
  1318         {
  1319           struct glyph_row *hl_row
  1320             = (w->current_matrix && w->current_matrix->rows
  1321                ? MATRIX_HEADER_LINE_ROW (w->current_matrix)
  1322                : 0);
  1323           if (hl_row && hl_row->mode_line_p)
  1324             height -= hl_row->height;
  1325           else
  1326             height -= estimate_mode_line_height (f, HEADER_LINE_FACE_ID);
  1327         }
  1328     }
  1329 
  1330   /* With a very small font and a mode-line that's taller than
  1331      default, we might end up with a negative height.  */
  1332   return max (0, height);
  1333 }
  1334 
  1335 /* Return the window-relative coordinate of the left edge of display
  1336    area AREA of window W.  ANY_AREA means return the left edge of the
  1337    whole window, to the right of the left fringe of W.  */
  1338 
  1339 int
  1340 window_box_left_offset (struct window *w, enum glyph_row_area area)
  1341 {
  1342   int x;
  1343 
  1344   if (w->pseudo_window_p)
  1345     return 0;
  1346 
  1347   x = WINDOW_LEFT_SCROLL_BAR_AREA_WIDTH (w);
  1348 
  1349   if (area == TEXT_AREA)
  1350     x += (WINDOW_LEFT_FRINGE_WIDTH (w)
  1351           + window_box_width (w, LEFT_MARGIN_AREA));
  1352   else if (area == RIGHT_MARGIN_AREA)
  1353     x += (WINDOW_LEFT_FRINGE_WIDTH (w)
  1354           + window_box_width (w, LEFT_MARGIN_AREA)
  1355           + window_box_width (w, TEXT_AREA)
  1356           + (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
  1357              ? 0
  1358              : WINDOW_RIGHT_FRINGE_WIDTH (w)));
  1359   else if (area == LEFT_MARGIN_AREA
  1360            && WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w))
  1361     x += WINDOW_LEFT_FRINGE_WIDTH (w);
  1362 
  1363   /* Don't return more than the window's pixel width.  */
  1364   return min (x, w->pixel_width);
  1365 }
  1366 
  1367 
  1368 /* Return the window-relative coordinate of the right edge of display
  1369    area AREA of window W.  ANY_AREA means return the right edge of the
  1370    whole window, to the left of the right fringe of W.  */
  1371 
  1372 static int
  1373 window_box_right_offset (struct window *w, enum glyph_row_area area)
  1374 {
  1375   /* Don't return more than the window's pixel width.  */
  1376   return min (window_box_left_offset (w, area) + window_box_width (w, area),
  1377               w->pixel_width);
  1378 }
  1379 
  1380 /* Return the frame-relative coordinate of the left edge of display
  1381    area AREA of window W.  ANY_AREA means return the left edge of the
  1382    whole window, to the right of the left fringe of W.  */
  1383 
  1384 int
  1385 window_box_left (struct window *w, enum glyph_row_area area)
  1386 {
  1387   struct frame *f = XFRAME (w->frame);
  1388   int x;
  1389 
  1390   if (w->pseudo_window_p)
  1391     return FRAME_INTERNAL_BORDER_WIDTH (f);
  1392 
  1393   x = (WINDOW_LEFT_EDGE_X (w)
  1394        + window_box_left_offset (w, area));
  1395 
  1396   return x;
  1397 }
  1398 
  1399 
  1400 /* Return the frame-relative coordinate of the right edge of display
  1401    area AREA of window W.  ANY_AREA means return the right edge of the
  1402    whole window, to the left of the right fringe of W.  */
  1403 
  1404 int
  1405 window_box_right (struct window *w, enum glyph_row_area area)
  1406 {
  1407   return window_box_left (w, area) + window_box_width (w, area);
  1408 }
  1409 
  1410 /* Get the bounding box of the display area AREA of window W, without
  1411    mode lines, in frame-relative coordinates.  ANY_AREA means the
  1412    whole window, not including the left and right fringes of
  1413    the window.  Return in *BOX_X and *BOX_Y the frame-relative pixel
  1414    coordinates of the upper-left corner of the box.  Return in
  1415    *BOX_WIDTH, and *BOX_HEIGHT the pixel width and height of the box.  */
  1416 
  1417 void
  1418 window_box (struct window *w, enum glyph_row_area area, int *box_x,
  1419             int *box_y, int *box_width, int *box_height)
  1420 {
  1421   if (box_width)
  1422     *box_width = window_box_width (w, area);
  1423   if (box_height)
  1424     *box_height = window_box_height (w);
  1425   if (box_x)
  1426     *box_x = window_box_left (w, area);
  1427   if (box_y)
  1428     {
  1429       *box_y = WINDOW_TOP_EDGE_Y (w);
  1430       if (window_wants_tab_line (w))
  1431         *box_y += CURRENT_TAB_LINE_HEIGHT (w);
  1432       if (window_wants_header_line (w))
  1433         *box_y += CURRENT_HEADER_LINE_HEIGHT (w);
  1434     }
  1435 }
  1436 
  1437 #ifdef HAVE_WINDOW_SYSTEM
  1438 
  1439 /* Get the bounding box of the display area AREA of window W, without
  1440    mode lines and both fringes of the window.  Return in *TOP_LEFT_X
  1441    and TOP_LEFT_Y the frame-relative pixel coordinates of the
  1442    upper-left corner of the box.  Return in *BOTTOM_RIGHT_X, and
  1443    *BOTTOM_RIGHT_Y the coordinates of the bottom-right corner of the
  1444    box.  */
  1445 
  1446 static void
  1447 window_box_edges (struct window *w, int *top_left_x, int *top_left_y,
  1448                   int *bottom_right_x, int *bottom_right_y)
  1449 {
  1450   window_box (w, ANY_AREA, top_left_x, top_left_y,
  1451               bottom_right_x, bottom_right_y);
  1452   *bottom_right_x += *top_left_x;
  1453   *bottom_right_y += *top_left_y;
  1454 }
  1455 
  1456 #endif /* HAVE_WINDOW_SYSTEM */
  1457 
  1458 /***********************************************************************
  1459                               Utilities
  1460  ***********************************************************************/
  1461 
  1462 /* Return the bottom y-position of the line the iterator IT is in.
  1463    This can modify IT's settings.  */
  1464 
  1465 int
  1466 line_bottom_y (struct it *it)
  1467 {
  1468   int line_height = it->max_ascent + it->max_descent;
  1469   int line_top_y = it->current_y;
  1470 
  1471   if (line_height == 0)
  1472     {
  1473       if (last_height)
  1474         line_height = last_height;
  1475       else if (IT_CHARPOS (*it) < ZV)
  1476         {
  1477           move_it_by_lines (it, 1);
  1478           line_height = (it->max_ascent || it->max_descent
  1479                          ? it->max_ascent + it->max_descent
  1480                          : last_height);
  1481         }
  1482       else
  1483         {
  1484           struct glyph_row *row = it->glyph_row;
  1485 
  1486           /* Use the default character height.  */
  1487           it->glyph_row = NULL;
  1488           it->what = IT_CHARACTER;
  1489           it->c = ' ';
  1490           it->len = 1;
  1491           PRODUCE_GLYPHS (it);
  1492           line_height = it->ascent + it->descent;
  1493           it->glyph_row = row;
  1494         }
  1495     }
  1496 
  1497   return line_top_y + line_height;
  1498 }
  1499 
  1500 DEFUN ("line-pixel-height", Fline_pixel_height,
  1501        Sline_pixel_height, 0, 0, 0,
  1502        doc: /* Return height in pixels of text line in the selected window.
  1503 
  1504 Value is the height in pixels of the line at point.  */)
  1505   (void)
  1506 {
  1507   struct it it;
  1508   struct text_pos pt;
  1509   struct window *w = XWINDOW (selected_window);
  1510   struct buffer *old_buffer = NULL;
  1511   Lisp_Object result;
  1512 
  1513   if (XBUFFER (w->contents) != current_buffer)
  1514     {
  1515       old_buffer = current_buffer;
  1516       set_buffer_internal_1 (XBUFFER (w->contents));
  1517     }
  1518   SET_TEXT_POS (pt, PT, PT_BYTE);
  1519   void *itdata = bidi_shelve_cache ();
  1520   start_display (&it, w, pt);
  1521   /* Start from the beginning of the screen line, to make sure we
  1522      traverse all of its display elements, and thus capture the
  1523      correct metrics.  */
  1524   move_it_by_lines (&it, 0);
  1525   it.vpos = it.current_y = 0;
  1526   last_height = 0;
  1527   result = make_fixnum (line_bottom_y (&it));
  1528   if (old_buffer)
  1529     set_buffer_internal_1 (old_buffer);
  1530 
  1531   bidi_unshelve_cache (itdata, false);
  1532   return result;
  1533 }
  1534 
  1535 /* Return the default pixel height of text lines in window W.  The
  1536    value is the canonical height of the W frame's default font, plus
  1537    any extra space required by the line-spacing variable or frame
  1538    parameter.
  1539 
  1540    Implementation note: this ignores any line-spacing text properties
  1541    put on the newline characters.  This is because those properties
  1542    only affect the _screen_ line ending in the newline (i.e., in a
  1543    continued line, only the last screen line will be affected), which
  1544    means only a small number of lines in a buffer can ever use this
  1545    feature.  Since this function is used to compute the default pixel
  1546    equivalent of text lines in a window, we can safely ignore those
  1547    few lines.  For the same reasons, we ignore the line-height
  1548    properties.  */
  1549 int
  1550 default_line_pixel_height (struct window *w)
  1551 {
  1552   struct frame *f = WINDOW_XFRAME (w);
  1553   int height = FRAME_LINE_HEIGHT (f);
  1554 
  1555   if (!FRAME_INITIAL_P (f) && BUFFERP (w->contents))
  1556     {
  1557       struct buffer *b = XBUFFER (w->contents);
  1558       Lisp_Object val = BVAR (b, extra_line_spacing);
  1559 
  1560       if (NILP (val))
  1561         val = BVAR (&buffer_defaults, extra_line_spacing);
  1562       if (!NILP (val))
  1563         {
  1564           if (RANGED_FIXNUMP (0, val, INT_MAX))
  1565             height += XFIXNAT (val);
  1566           else if (FLOATP (val))
  1567             {
  1568               int addon = XFLOAT_DATA (val) * height + 0.5;
  1569 
  1570               if (addon >= 0)
  1571                 height += addon;
  1572             }
  1573         }
  1574       else
  1575         height += f->extra_line_spacing;
  1576     }
  1577 
  1578   return height;
  1579 }
  1580 
  1581 /* Subroutine of pos_visible_p below.  Extracts a display string, if
  1582    any, from the display spec given as its argument.  */
  1583 static Lisp_Object
  1584 string_from_display_spec (Lisp_Object spec)
  1585 {
  1586   if (VECTORP (spec))
  1587     {
  1588       for (ptrdiff_t i = 0; i < ASIZE (spec); i++)
  1589         if (STRINGP (AREF (spec, i)))
  1590           return AREF (spec, i);
  1591     }
  1592   else
  1593     {
  1594       for (; CONSP (spec); spec = XCDR (spec))
  1595         if (STRINGP (XCAR (spec)))
  1596           return XCAR (spec);
  1597     }
  1598   return spec;
  1599 }
  1600 
  1601 
  1602 /* Limit insanely large values of W->hscroll on frame F to the largest
  1603    value that will still prevent first_visible_x and last_visible_x of
  1604    'struct it' from overflowing an int.  */
  1605 static int
  1606 window_hscroll_limited (struct window *w, struct frame *f)
  1607 {
  1608   ptrdiff_t window_hscroll = w->hscroll;
  1609   int window_text_width = window_box_width (w, TEXT_AREA);
  1610   int colwidth = FRAME_COLUMN_WIDTH (f);
  1611 
  1612   if (window_hscroll > (INT_MAX - window_text_width) / colwidth - 1)
  1613     window_hscroll = (INT_MAX - window_text_width) / colwidth - 1;
  1614 
  1615   return window_hscroll;
  1616 }
  1617 
  1618 /* Reset the box-face start and end flags in the iterator.  This is
  1619    called after producing glyphs, such that we reset these flags only
  1620    after producing a glyph with the flag set.  */
  1621 
  1622 static void
  1623 reset_box_start_end_flags (struct it *it)
  1624 {
  1625   /* Don't reset if we've drawn the glyph in the display margins --
  1626      those don't count as "produced glyphs".  */
  1627   if (it->area == TEXT_AREA
  1628       /* Don't reset if we displayed a fringe bitmap.  */
  1629       && !(it->what == IT_IMAGE && it->image_id < 0))
  1630     {
  1631       /* Don't reset if the face is not a box face: that might mean we
  1632          are iterating some overlay or display string, and the first
  1633          character to have the box face is yet to be seen, when we pop
  1634          the iterator stack. */
  1635       if (it->face_box_p)
  1636         it->start_of_box_run_p = false;
  1637       it->end_of_box_run_p = false;
  1638     }
  1639 }
  1640 
  1641 /* Return true if position CHARPOS is visible in window W.
  1642    CHARPOS < 0 means return info about WINDOW_END position.
  1643    If visible, set *X and *Y to pixel coordinates of top left corner.
  1644    Set *RTOP and *RBOT to pixel height of an invisible area of glyph at POS.
  1645    Set *ROWH and *VPOS to row's visible height and VPOS (row number).  */
  1646 
  1647 bool
  1648 pos_visible_p (struct window *w, ptrdiff_t charpos, int *x, int *y,
  1649                int *rtop, int *rbot, int *rowh, int *vpos)
  1650 {
  1651   struct it it;
  1652   void *itdata = bidi_shelve_cache ();
  1653   struct text_pos top;
  1654   bool visible_p = false;
  1655   struct buffer *old_buffer = NULL;
  1656   bool r2l = false;
  1657 
  1658   if (FRAME_INITIAL_P (XFRAME (WINDOW_FRAME (w))))
  1659     return visible_p;
  1660 
  1661   if (XBUFFER (w->contents) != current_buffer)
  1662     {
  1663       old_buffer = current_buffer;
  1664       set_buffer_internal_1 (XBUFFER (w->contents));
  1665     }
  1666 
  1667   SET_TEXT_POS_FROM_MARKER (top, w->start);
  1668   /* Scrolling a minibuffer window via scroll bar when the echo area
  1669      shows long text sometimes resets the minibuffer contents behind
  1670      our backs.  Also, someone might narrow-to-region and immediately
  1671      call a scroll function.  */
  1672   if (CHARPOS (top) > ZV || CHARPOS (top) < BEGV)
  1673     SET_TEXT_POS (top, BEGV, BEGV_BYTE);
  1674 
  1675   /* If the top of the window is after CHARPOS, the latter is surely
  1676      not visible.  */
  1677   if (charpos >= 0 && CHARPOS (top) > charpos)
  1678     return visible_p;
  1679 
  1680   /* Some Lisp hook could call us in the middle of redisplaying this
  1681      very window.  If, by some bad luck, we are retrying redisplay
  1682      because we found that the mode-line height and/or tab/header-line
  1683      height needs to be updated, the assignment of mode_line_height
  1684      and header_line_height below could disrupt that, due to the
  1685      selected/nonselected window dance during mode-line display, and
  1686      we could infloop.  Avoid that.  */
  1687   int prev_mode_line_height = w->mode_line_height;
  1688   int prev_header_line_height = w->header_line_height;
  1689   int prev_tab_line_height = w->tab_line_height;
  1690   /* Compute exact mode line heights.  */
  1691   if (window_wants_mode_line (w))
  1692     {
  1693       Lisp_Object window_mode_line_format
  1694         = window_parameter (w, Qmode_line_format);
  1695 
  1696       w->mode_line_height
  1697         = display_mode_line (w, CURRENT_MODE_LINE_ACTIVE_FACE_ID (w),
  1698                              NILP (window_mode_line_format)
  1699                              ? BVAR (current_buffer, mode_line_format)
  1700                              : window_mode_line_format);
  1701     }
  1702 
  1703   if (window_wants_tab_line (w))
  1704     {
  1705       Lisp_Object window_tab_line_format
  1706         = window_parameter (w, Qtab_line_format);
  1707 
  1708       w->tab_line_height
  1709         = display_mode_line (w, TAB_LINE_FACE_ID,
  1710                              NILP (window_tab_line_format)
  1711                              ? BVAR (current_buffer, tab_line_format)
  1712                              : window_tab_line_format);
  1713     }
  1714 
  1715   if (window_wants_header_line (w))
  1716     {
  1717       Lisp_Object window_header_line_format
  1718         = window_parameter (w, Qheader_line_format);
  1719 
  1720       w->header_line_height
  1721         = display_mode_line (w, HEADER_LINE_FACE_ID,
  1722                              NILP (window_header_line_format)
  1723                              ? BVAR (current_buffer, header_line_format)
  1724                              : window_header_line_format);
  1725     }
  1726 
  1727   start_display (&it, w, top);
  1728   move_it_to (&it, charpos, -1, it.last_visible_y - 1, -1,
  1729               (charpos >= 0 ? MOVE_TO_POS : 0) | MOVE_TO_Y);
  1730 
  1731   /* Adjust for line numbers, if CHARPOS is at or beyond first_visible_x,
  1732      but we didn't yet produce the line-number glyphs.  */
  1733   if (!NILP (Vdisplay_line_numbers)
  1734       && it.current_x >= it.first_visible_x
  1735       && IT_CHARPOS (it) == charpos
  1736       && !it.line_number_produced_p)
  1737     {
  1738       /* If the pixel width of line numbers was not yet known, compute
  1739          it now.  This usually happens in the first display line of a
  1740          window.  */
  1741       if (!it.lnum_pixel_width)
  1742         {
  1743           struct it it2;
  1744           void *it2data = NULL;
  1745 
  1746           SAVE_IT (it2, it, it2data);
  1747           move_it_by_lines (&it, 1);
  1748           it2.lnum_pixel_width = it.lnum_pixel_width;
  1749           RESTORE_IT (&it, &it2, it2data);
  1750         }
  1751       it.current_x += it.lnum_pixel_width;
  1752     }
  1753 
  1754   if (charpos >= 0
  1755       && (((!it.bidi_p || it.bidi_it.scan_dir != -1)
  1756            && IT_CHARPOS (it) >= charpos)
  1757           /* When scanning backwards under bidi iteration, move_it_to
  1758              stops at or _before_ CHARPOS, because it stops at or to
  1759              the _right_ of the character at CHARPOS.  */
  1760           || (it.bidi_p && it.bidi_it.scan_dir == -1
  1761               && IT_CHARPOS (it) <= charpos)))
  1762     {
  1763       /* We have reached CHARPOS, or passed it.  How the call to
  1764          move_it_to can overshoot: (i) If CHARPOS is on invisible text
  1765          or covered by a display property, move_it_to stops at the end
  1766          of the invisible text, to the right of CHARPOS.  (ii) If
  1767          CHARPOS is in a display vector, move_it_to stops on its last
  1768          glyph.  */
  1769       int top_x = it.current_x;
  1770       int top_y = it.current_y;
  1771       int window_top_y = WINDOW_TAB_LINE_HEIGHT (w) + WINDOW_HEADER_LINE_HEIGHT (w);
  1772       int bottom_y;
  1773       struct it save_it;
  1774       void *save_it_data = NULL;
  1775 
  1776       /* Calling line_bottom_y may change it.method, it.position, etc.  */
  1777       SAVE_IT (save_it, it, save_it_data);
  1778       last_height = 0;
  1779       bottom_y = line_bottom_y (&it);
  1780       if (top_y < window_top_y)
  1781         visible_p = bottom_y > window_top_y;
  1782       else if (top_y < it.last_visible_y)
  1783         visible_p = true;
  1784       if (bottom_y >= it.last_visible_y
  1785           && it.bidi_p && it.bidi_it.scan_dir == -1
  1786           && IT_CHARPOS (it) < charpos)
  1787         {
  1788           /* When the last line of the window is scanned backwards
  1789              under bidi iteration, we could be duped into thinking
  1790              that we have passed CHARPOS, when in fact move_it_to
  1791              simply stopped short of CHARPOS because it reached
  1792              last_visible_y.  To see if that's what happened, we call
  1793              move_it_to again with a slightly larger vertical limit,
  1794              and see if it actually moved vertically; if it did, we
  1795              didn't really reach CHARPOS, which is beyond window end.  */
  1796           /* Why 10? because we don't know how many canonical lines
  1797              will the height of the next line(s) be.  So we guess.  */
  1798           int ten_more_lines = 10 * default_line_pixel_height (w);
  1799 
  1800           move_it_to (&it, charpos, -1, bottom_y + ten_more_lines, -1,
  1801                       MOVE_TO_POS | MOVE_TO_Y);
  1802           if (it.current_y > top_y)
  1803             visible_p = false;
  1804 
  1805         }
  1806       RESTORE_IT (&it, &save_it, save_it_data);
  1807       if (visible_p)
  1808         {
  1809           if (it.method == GET_FROM_DISPLAY_VECTOR)
  1810             {
  1811               /* We stopped on the last glyph of a display vector.
  1812                  Try and recompute.  Hack alert!  */
  1813               if (charpos < 2 || top.charpos >= charpos)
  1814                 top_x = it.glyph_row->x;
  1815               else
  1816                 {
  1817                   struct it it2, it2_prev;
  1818                   /* The idea is to get to the previous buffer
  1819                      position, consume the character there, and use
  1820                      the pixel coordinates we get after that.  But if
  1821                      the previous buffer position is also displayed
  1822                      from a display vector, we need to consume all of
  1823                      the glyphs from that display vector.  */
  1824                   start_display (&it2, w, top);
  1825                   it2.glyph_row = NULL;
  1826                   move_it_to (&it2, charpos - 1, -1, -1, -1, MOVE_TO_POS);
  1827                   /* If we didn't get to CHARPOS - 1, there's some
  1828                      replacing display property at that position, and
  1829                      we stopped after it.  That is exactly the place
  1830                      whose coordinates we want.  */
  1831                   if (IT_CHARPOS (it2) != charpos - 1)
  1832                     it2_prev = it2;
  1833                   else
  1834                     {
  1835                       /* Iterate until we get out of the display
  1836                          vector that displays the character at
  1837                          CHARPOS - 1.  */
  1838                       do {
  1839                         get_next_display_element (&it2);
  1840                         PRODUCE_GLYPHS (&it2);
  1841                         it2_prev = it2;
  1842                         set_iterator_to_next (&it2, true);
  1843                       } while (it2.method == GET_FROM_DISPLAY_VECTOR
  1844                                && IT_CHARPOS (it2) < charpos);
  1845                     }
  1846                   if (ITERATOR_AT_END_OF_LINE_P (&it2_prev)
  1847                       || it2_prev.current_x > it2_prev.last_visible_x)
  1848                     top_x = it.glyph_row->x;
  1849                   else
  1850                     {
  1851                       top_x = it2_prev.current_x;
  1852                       top_y = it2_prev.current_y;
  1853                     }
  1854                 }
  1855             }
  1856           else if (IT_CHARPOS (it) != charpos)
  1857             {
  1858               Lisp_Object cpos = make_fixnum (charpos);
  1859               Lisp_Object spec = Fget_char_property (cpos, Qdisplay, Qnil);
  1860               Lisp_Object string = string_from_display_spec (spec);
  1861               struct text_pos tpos;
  1862               bool newline_in_string
  1863                 = (STRINGP (string)
  1864                    && memchr (SDATA (string), '\n', SBYTES (string)));
  1865 
  1866               SET_TEXT_POS (tpos, charpos, CHAR_TO_BYTE (charpos));
  1867               bool replacing_spec_p
  1868                 = (!NILP (spec)
  1869                    && handle_display_spec (NULL, spec, Qnil, Qnil, &tpos,
  1870                                            charpos, FRAME_WINDOW_P (it.f)));
  1871               /* The tricky code below is needed because there's a
  1872                  discrepancy between move_it_to and how we set cursor
  1873                  when PT is at the beginning of a portion of text
  1874                  covered by a display property or an overlay with a
  1875                  display property, or the display line ends in a
  1876                  newline from a display string.  move_it_to will stop
  1877                  _after_ such display strings, whereas
  1878                  set_cursor_from_row conspires with cursor_row_p to
  1879                  place the cursor on the first glyph produced from the
  1880                  display string.  */
  1881 
  1882               /* We have overshoot PT because it is covered by a
  1883                  display property that replaces the text it covers.
  1884                  If the string includes embedded newlines, we are also
  1885                  in the wrong display line.  Backtrack to the correct
  1886                  line, where the display property begins.  */
  1887               if (replacing_spec_p)
  1888                 {
  1889                   Lisp_Object startpos, endpos;
  1890                   EMACS_INT start, end;
  1891                   struct it it3;
  1892 
  1893                   /* Find the first and the last buffer positions
  1894                      covered by the display string.  */
  1895                   endpos =
  1896                     Fnext_single_char_property_change (cpos, Qdisplay,
  1897                                                        Qnil, Qnil);
  1898                   startpos =
  1899                     Fprevious_single_char_property_change (endpos, Qdisplay,
  1900                                                            Qnil, Qnil);
  1901                   start = XFIXNAT (startpos);
  1902                   end = XFIXNAT (endpos);
  1903                   /* Move to the last buffer position before the
  1904                      display property.  */
  1905                   start_display (&it3, w, top);
  1906                   if (start > CHARPOS (top))
  1907                     move_it_to (&it3, start - 1, -1, -1, -1, MOVE_TO_POS);
  1908                   /* Move forward one more line if the position before
  1909                      the display string is a newline or if it is the
  1910                      rightmost character on a line that is
  1911                      continued or word-wrapped.  */
  1912                   if (it3.method == GET_FROM_BUFFER
  1913                       && (it3.c == '\n'
  1914                           || FETCH_BYTE (IT_BYTEPOS (it3)) == '\n'))
  1915                     move_it_by_lines (&it3, 1);
  1916                   else if (move_it_in_display_line_to (&it3, -1,
  1917                                                        it3.current_x
  1918                                                        + it3.pixel_width,
  1919                                                        MOVE_TO_X)
  1920                            == MOVE_LINE_CONTINUED)
  1921                     {
  1922                       move_it_by_lines (&it3, 1);
  1923                       /* When we are under word-wrap, the #$@%!
  1924                          move_it_by_lines moves 2 lines, so we need to
  1925                          fix that up.  */
  1926                       if (it3.line_wrap == WORD_WRAP)
  1927                         move_it_by_lines (&it3, -1);
  1928                     }
  1929 
  1930                   /* Record the vertical coordinate of the display
  1931                      line where we wound up.  */
  1932                   top_y = it3.current_y;
  1933                   if (it3.bidi_p)
  1934                     {
  1935                       /* When characters are reordered for display,
  1936                          the character displayed to the left of the
  1937                          display string could be _after_ the display
  1938                          property in the logical order.  Use the
  1939                          smallest vertical position of these two.  */
  1940                       start_display (&it3, w, top);
  1941                       move_it_to (&it3, end + 1, -1, -1, -1, MOVE_TO_POS);
  1942                       if (it3.current_y < top_y)
  1943                         top_y = it3.current_y;
  1944                     }
  1945                   /* Move from the top of the window to the beginning
  1946                      of the display line where the display string
  1947                      begins.  */
  1948                   start_display (&it3, w, top);
  1949                   it3.glyph_row = NULL;
  1950                   move_it_to (&it3, -1, 0, top_y, -1, MOVE_TO_X | MOVE_TO_Y);
  1951                   /* If it3_moved stays false after the 'while' loop
  1952                      below, that means we already were at a newline
  1953                      before the loop (e.g., the display string begins
  1954                      with a newline), so we don't need to return to
  1955                      the last position before the display string,
  1956                      because PRODUCE_GLYPHS will not produce anything
  1957                      for a newline.  */
  1958                   bool it3_moved = false;
  1959                   int top_x_before_string = it3.current_x;
  1960                   /* Finally, advance the iterator until we hit the
  1961                      first display element whose character position is
  1962                      at or beyond CHARPOS, or until the first newline
  1963                      from the display string, which signals the end of
  1964                      the display line.  */
  1965                   while (get_next_display_element (&it3))
  1966                     {
  1967                       if (!EQ (it3.object, string))
  1968                         top_x_before_string = it3.current_x;
  1969                       PRODUCE_GLYPHS (&it3);
  1970                       if ((it3.bidi_it.scan_dir == 1
  1971                            && IT_CHARPOS (it3) >= charpos)
  1972                           || (it3.bidi_it.scan_dir == -1
  1973                               && IT_CHARPOS (it3) <= charpos)
  1974                           || ITERATOR_AT_END_OF_LINE_P (&it3))
  1975                         break;
  1976                       it3_moved = true;
  1977                       set_iterator_to_next (&it3, false);
  1978                     }
  1979                   top_x = it3.current_x - it3.pixel_width;
  1980                   /* Account for line-number display, if IT3 still
  1981                      didn't.  This can happen if START - 1 is the
  1982                      first or the last character on its display line.  */
  1983                   if (!it3.line_number_produced_p)
  1984                     {
  1985                       if (it3.lnum_pixel_width > 0)
  1986                         {
  1987                           top_x += it3.lnum_pixel_width;
  1988                           top_x_before_string += it3.lnum_pixel_width;
  1989                         }
  1990                       else if (it.line_number_produced_p)
  1991                         {
  1992                           top_x += it.lnum_pixel_width;
  1993                           top_x_before_string += it3.lnum_pixel_width;
  1994                         }
  1995                     }
  1996                   /* Normally, we would exit the above loop because we
  1997                      found the display element whose character
  1998                      position is CHARPOS.  For the contingency that we
  1999                      didn't, and stopped at the first newline from the
  2000                      display string, reset top_x to the coordinate of
  2001                      the rightmost glyph not from the string.  */
  2002                   if (it3_moved
  2003                       && newline_in_string
  2004                       && IT_CHARPOS (it3) != charpos && EQ (it3.object, string))
  2005                     top_x = top_x_before_string;
  2006                 }
  2007             }
  2008 
  2009           *x = top_x;
  2010           /* The condition below is a heuristic fix for the situation
  2011              where move_it_to stops just after finishing the display
  2012              of a fringe bitmap, which resets it.ascent to zero, and
  2013              thus causes Y to be offset by it.max_ascent.  */
  2014           if (it.ascent == 0 && it.what == IT_IMAGE
  2015               && it.method != GET_FROM_IMAGE
  2016               && it.image_id < 0
  2017               && it.max_ascent > 0)
  2018             *y = max (top_y, window_top_y);
  2019           else
  2020             *y = max (top_y + max (0, it.max_ascent - it.ascent), window_top_y);
  2021           *rtop = max (0, window_top_y - top_y);
  2022           *rbot = max (0, bottom_y - it.last_visible_y);
  2023           *rowh = max (0, (min (bottom_y, it.last_visible_y)
  2024                            - max (top_y, window_top_y)));
  2025           *vpos = it.vpos;
  2026           if (it.bidi_it.paragraph_dir == R2L)
  2027             r2l = true;
  2028         }
  2029     }
  2030   else
  2031     {
  2032       /* Either we were asked to provide info about WINDOW_END, or
  2033          CHARPOS is in the partially visible glyph row at end of
  2034          window.  */
  2035       struct it it2;
  2036       void *it2data = NULL;
  2037 
  2038       SAVE_IT (it2, it, it2data);
  2039       if (IT_CHARPOS (it) < ZV && FETCH_BYTE (IT_BYTEPOS (it)) != '\n')
  2040         move_it_by_lines (&it, 1);
  2041       if (charpos < IT_CHARPOS (it)
  2042           || (it.what == IT_EOB && charpos == IT_CHARPOS (it)))
  2043         {
  2044           visible_p = true;
  2045           RESTORE_IT (&it2, &it2, it2data);
  2046           move_it_to (&it2, charpos, -1, -1, -1, MOVE_TO_POS);
  2047           *x = it2.current_x;
  2048           if (it2.ascent == 0 && it2.what == IT_IMAGE
  2049               && it2.method != GET_FROM_IMAGE
  2050               && it2.image_id < 0
  2051               && it2.max_ascent > 0)
  2052             *y = it2.current_y;
  2053           else
  2054             *y = it2.current_y + it2.max_ascent - it2.ascent;
  2055           *rtop = max (0, -it2.current_y);
  2056           *rbot = max (0, ((it2.current_y + it2.max_ascent + it2.max_descent)
  2057                            - it.last_visible_y));
  2058           *rowh = max (0, (min (it2.current_y + it2.max_ascent + it2.max_descent,
  2059                                 it.last_visible_y)
  2060                            - max (max (it2.current_y,
  2061                                        WINDOW_TAB_LINE_HEIGHT (w)),
  2062                                   WINDOW_HEADER_LINE_HEIGHT (w))));
  2063           *vpos = it2.vpos;
  2064           if (it2.bidi_it.paragraph_dir == R2L)
  2065             r2l = true;
  2066         }
  2067       else
  2068         bidi_unshelve_cache (it2data, true);
  2069     }
  2070   bidi_unshelve_cache (itdata, false);
  2071 
  2072   if (old_buffer)
  2073     set_buffer_internal_1 (old_buffer);
  2074 
  2075   if (visible_p)
  2076     {
  2077       if (w->hscroll > 0)
  2078         *x -=
  2079           window_hscroll_limited (w, WINDOW_XFRAME (w))
  2080           * WINDOW_FRAME_COLUMN_WIDTH (w);
  2081       /* For lines in an R2L paragraph, we need to mirror the X pixel
  2082          coordinate wrt the text area.  For the reasons, see the
  2083          commentary in buffer_posn_from_coords and the explanation of
  2084          the geometry used by the move_it_* functions at the end of
  2085          the large commentary near the beginning of this file.  */
  2086       if (r2l)
  2087         *x = window_box_width (w, TEXT_AREA) - *x - 1;
  2088     }
  2089 
  2090 #if false
  2091   /* Debugging code.  */
  2092   if (visible_p)
  2093     fprintf (stderr, "+pv pt=%d vs=%d --> x=%d y=%d rt=%d rb=%d rh=%d vp=%d\n",
  2094              charpos, w->vscroll, *x, *y, *rtop, *rbot, *rowh, *vpos);
  2095   else
  2096     fprintf (stderr, "-pv pt=%d vs=%d\n", charpos, w->vscroll);
  2097 #endif
  2098 
  2099   /* Restore potentially overwritten values.  */
  2100   w->mode_line_height = prev_mode_line_height;
  2101   w->header_line_height = prev_header_line_height;
  2102   w->tab_line_height = prev_tab_line_height;
  2103 
  2104   return visible_p;
  2105 }
  2106 
  2107 
  2108 /* Return the next character from STR.  Return in *LEN the length of
  2109    the character.  This is like string_char_and_length but never
  2110    returns an invalid character.  If we find one, we return a `?', but
  2111    with the length of the invalid character.  */
  2112 
  2113 static int
  2114 check_char_and_length (const unsigned char *str, int *len)
  2115 {
  2116   int c = string_char_and_length (str, len);
  2117   if (!CHAR_VALID_P (c))
  2118     /* We may not change the length here because other places in Emacs
  2119        don't use this function, i.e. they silently accept invalid
  2120        characters.  */
  2121     c = '?';
  2122 
  2123   return c;
  2124 }
  2125 
  2126 
  2127 
  2128 /* Given a position POS containing a valid character and byte position
  2129    in STRING, return the position NCHARS ahead (NCHARS >= 0).  */
  2130 
  2131 static struct text_pos
  2132 string_pos_nchars_ahead (struct text_pos pos, Lisp_Object string, ptrdiff_t nchars)
  2133 {
  2134   eassert (STRINGP (string) && nchars >= 0);
  2135 
  2136   if (STRING_MULTIBYTE (string))
  2137     {
  2138       const unsigned char *p = SDATA (string) + BYTEPOS (pos);
  2139 
  2140       while (nchars--)
  2141         {
  2142           int len = BYTES_BY_CHAR_HEAD (*p);
  2143           p += len;
  2144           CHARPOS (pos) += 1;
  2145           BYTEPOS (pos) += len;
  2146         }
  2147     }
  2148   else
  2149     SET_TEXT_POS (pos, CHARPOS (pos) + nchars, BYTEPOS (pos) + nchars);
  2150 
  2151   return pos;
  2152 }
  2153 
  2154 
  2155 /* Value is the text position, i.e. character and byte position,
  2156    for character position CHARPOS in STRING.  */
  2157 
  2158 static struct text_pos
  2159 string_pos (ptrdiff_t charpos, Lisp_Object string)
  2160 {
  2161   struct text_pos pos;
  2162   eassert (STRINGP (string));
  2163   eassert (charpos >= 0);
  2164   SET_TEXT_POS (pos, charpos, string_char_to_byte (string, charpos));
  2165   return pos;
  2166 }
  2167 
  2168 
  2169 /* Value is a text position, i.e. character and byte position, for
  2170    character position CHARPOS in C string S.  MULTIBYTE_P
  2171    means recognize multibyte characters.  */
  2172 
  2173 static struct text_pos
  2174 c_string_pos (ptrdiff_t charpos, const char *s, bool multibyte_p)
  2175 {
  2176   struct text_pos pos;
  2177 
  2178   eassert (s != NULL);
  2179   eassert (charpos >= 0);
  2180 
  2181   if (multibyte_p)
  2182     {
  2183       SET_TEXT_POS (pos, 0, 0);
  2184       while (charpos--)
  2185         {
  2186           int len = BYTES_BY_CHAR_HEAD (*s);
  2187           s += len;
  2188           CHARPOS (pos) += 1;
  2189           BYTEPOS (pos) += len;
  2190         }
  2191     }
  2192   else
  2193     SET_TEXT_POS (pos, charpos, charpos);
  2194 
  2195   return pos;
  2196 }
  2197 
  2198 
  2199 /* Value is the number of characters in C string S.  MULTIBYTE_P
  2200    means recognize multibyte characters.  */
  2201 
  2202 static ptrdiff_t
  2203 number_of_chars (const char *s, bool multibyte_p)
  2204 {
  2205   ptrdiff_t nchars;
  2206 
  2207   if (multibyte_p)
  2208     {
  2209       ptrdiff_t rest = strlen (s);
  2210       const unsigned char *p = (const unsigned char *) s;
  2211 
  2212       for (nchars = 0; rest > 0; ++nchars)
  2213         {
  2214           int len = BYTES_BY_CHAR_HEAD (*p);
  2215           rest -= len, p += len;
  2216         }
  2217     }
  2218   else
  2219     nchars = strlen (s);
  2220 
  2221   return nchars;
  2222 }
  2223 
  2224 
  2225 /* Compute byte position NEWPOS->bytepos corresponding to
  2226    NEWPOS->charpos.  POS is a known position in string STRING.
  2227    NEWPOS->charpos must be >= POS.charpos.  */
  2228 
  2229 static void
  2230 compute_string_pos (struct text_pos *newpos, struct text_pos pos, Lisp_Object string)
  2231 {
  2232   eassert (STRINGP (string));
  2233   eassert (CHARPOS (*newpos) >= CHARPOS (pos));
  2234 
  2235   if (STRING_MULTIBYTE (string))
  2236     *newpos = string_pos_nchars_ahead (pos, string,
  2237                                        CHARPOS (*newpos) - CHARPOS (pos));
  2238   else
  2239     BYTEPOS (*newpos) = CHARPOS (*newpos);
  2240 }
  2241 
  2242 /* EXPORT:
  2243    Return an estimation of the pixel height of mode or header lines on
  2244    frame F.  FACE_ID specifies what line's height to estimate.  */
  2245 
  2246 int
  2247 estimate_mode_line_height (struct frame *f, enum face_id face_id)
  2248 {
  2249 #ifdef HAVE_WINDOW_SYSTEM
  2250   if (FRAME_WINDOW_P (f))
  2251     {
  2252       int height = FONT_HEIGHT (FRAME_FONT (f));
  2253 
  2254       /* This function is called so early when Emacs starts that the face
  2255          cache and mode line face are not yet initialized.  */
  2256       if (FRAME_FACE_CACHE (f))
  2257         {
  2258           struct face *face = FACE_FROM_ID_OR_NULL (f, face_id);
  2259           if (face)
  2260             {
  2261               if (face->font)
  2262                 height = normal_char_height (face->font, -1);
  2263               if (face->box_horizontal_line_width > 0)
  2264                 height += 2 * face->box_horizontal_line_width;
  2265             }
  2266         }
  2267 
  2268       return height;
  2269     }
  2270 #endif
  2271 
  2272   return 1;
  2273 }
  2274 
  2275 /* Given a pixel position (PIX_X, PIX_Y) on frame F, return glyph
  2276    coordinates in (*X, *Y).  Set *BOUNDS to the rectangle that the
  2277    glyph at X, Y occupies, if BOUNDS != 0.  If NOCLIP, do
  2278    not force the value into range.  */
  2279 
  2280 void
  2281 pixel_to_glyph_coords (struct frame *f, int pix_x, int pix_y, int *x, int *y,
  2282                        NativeRectangle *bounds, bool noclip)
  2283 {
  2284 
  2285 #ifdef HAVE_WINDOW_SYSTEM
  2286   if (FRAME_WINDOW_P (f))
  2287     {
  2288       /* Arrange for the division in FRAME_PIXEL_X_TO_COL etc. to round down
  2289          even for negative values.  */
  2290       if (pix_x < 0)
  2291         pix_x -= FRAME_COLUMN_WIDTH (f) - 1;
  2292       if (pix_y < 0)
  2293         pix_y -= FRAME_LINE_HEIGHT (f) - 1;
  2294 
  2295       pix_x = FRAME_PIXEL_X_TO_COL (f, pix_x);
  2296       pix_y = FRAME_PIXEL_Y_TO_LINE (f, pix_y);
  2297 
  2298       if (bounds)
  2299         STORE_NATIVE_RECT (*bounds,
  2300                            FRAME_COL_TO_PIXEL_X (f, pix_x),
  2301                            FRAME_LINE_TO_PIXEL_Y (f, pix_y),
  2302                            FRAME_COLUMN_WIDTH (f) - 1,
  2303                            FRAME_LINE_HEIGHT (f) - 1);
  2304 
  2305       /* PXW: Should we clip pixels before converting to columns/lines?  */
  2306       if (!noclip)
  2307         {
  2308           if (pix_x < 0)
  2309             pix_x = 0;
  2310           else if (pix_x > FRAME_TOTAL_COLS (f))
  2311             pix_x = FRAME_TOTAL_COLS (f);
  2312 
  2313           if (pix_y < 0)
  2314             pix_y = 0;
  2315           else if (pix_y > FRAME_TOTAL_LINES (f))
  2316             pix_y = FRAME_TOTAL_LINES (f);
  2317         }
  2318     }
  2319 #endif
  2320 
  2321   *x = pix_x;
  2322   *y = pix_y;
  2323 }
  2324 
  2325 
  2326 /* Find the glyph under window-relative coordinates X/Y in window W.
  2327    Consider only glyphs from buffer text, i.e. no glyphs from overlay
  2328    strings.  Return in *HPOS and *VPOS the row and column number of
  2329    the glyph found.  Return in *AREA the glyph area containing X.
  2330    Value is a pointer to the glyph found or null if X/Y is not on
  2331    text, or we can't tell because W's current matrix is not up to
  2332    date.  */
  2333 
  2334 struct glyph *
  2335 x_y_to_hpos_vpos (struct window *w, int x, int y, int *hpos, int *vpos,
  2336                   int *dx, int *dy, int *area)
  2337 {
  2338   struct glyph *glyph, *end;
  2339   struct glyph_row *row = NULL;
  2340   int x0, i;
  2341 
  2342   /* Find row containing Y.  Give up if some row is not enabled.  */
  2343   for (i = 0; i < w->current_matrix->nrows; ++i)
  2344     {
  2345       row = MATRIX_ROW (w->current_matrix, i);
  2346       if (!row->enabled_p)
  2347         return NULL;
  2348       if (y >= row->y && y < MATRIX_ROW_BOTTOM_Y (row))
  2349         break;
  2350     }
  2351 
  2352   *vpos = i;
  2353   *hpos = 0;
  2354 
  2355   /* Give up if Y is not in the window.  */
  2356   if (i == w->current_matrix->nrows)
  2357     return NULL;
  2358 
  2359   /* Get the glyph area containing X.  */
  2360   if (w->pseudo_window_p)
  2361     {
  2362       *area = TEXT_AREA;
  2363       x0 = 0;
  2364     }
  2365   else
  2366     {
  2367       if (x < window_box_left_offset (w, TEXT_AREA))
  2368         {
  2369           *area = LEFT_MARGIN_AREA;
  2370           x0 = window_box_left_offset (w, LEFT_MARGIN_AREA);
  2371         }
  2372       else if (x < window_box_right_offset (w, TEXT_AREA))
  2373         {
  2374           *area = TEXT_AREA;
  2375           x0 = window_box_left_offset (w, TEXT_AREA) + min (row->x, 0);
  2376         }
  2377       else
  2378         {
  2379           *area = RIGHT_MARGIN_AREA;
  2380           x0 = window_box_left_offset (w, RIGHT_MARGIN_AREA);
  2381         }
  2382     }
  2383 
  2384   /* Find glyph containing X.  */
  2385   glyph = row->glyphs[*area];
  2386   end = glyph + row->used[*area];
  2387   x -= x0;
  2388   while (glyph < end && x >= glyph->pixel_width)
  2389     {
  2390       x -= glyph->pixel_width;
  2391       ++glyph;
  2392     }
  2393 
  2394   if (glyph == end)
  2395     return NULL;
  2396 
  2397   if (dx)
  2398     {
  2399       *dx = x;
  2400       *dy = y - (row->y + row->ascent - glyph->ascent);
  2401     }
  2402 
  2403   *hpos = glyph - row->glyphs[*area];
  2404   return glyph;
  2405 }
  2406 
  2407 /* Convert frame-relative x/y to coordinates relative to window W.
  2408    Takes pseudo-windows into account.  */
  2409 
  2410 static void
  2411 frame_to_window_pixel_xy (struct window *w, int *x, int *y)
  2412 {
  2413   if (w->pseudo_window_p)
  2414     {
  2415       /* A pseudo-window is always full-width, and starts at the
  2416          left edge of the frame, plus a frame border.  */
  2417       struct frame *f = XFRAME (w->frame);
  2418       *x -= FRAME_INTERNAL_BORDER_WIDTH (f);
  2419       *y = FRAME_TO_WINDOW_PIXEL_Y (w, *y);
  2420     }
  2421   else
  2422     {
  2423       *x -= WINDOW_LEFT_EDGE_X (w);
  2424       *y = FRAME_TO_WINDOW_PIXEL_Y (w, *y);
  2425     }
  2426 }
  2427 
  2428 #ifdef HAVE_WINDOW_SYSTEM
  2429 
  2430 /* EXPORT:
  2431    Return in RECTS[] at most N clipping rectangles for glyph string S.
  2432    Return the number of stored rectangles.  */
  2433 
  2434 int
  2435 get_glyph_string_clip_rects (struct glyph_string *s, NativeRectangle *rects, int n)
  2436 {
  2437   Emacs_Rectangle r;
  2438 
  2439   if (n <= 0)
  2440     return 0;
  2441 
  2442   if (s->row->full_width_p)
  2443     {
  2444       /* Draw full-width.  X coordinates are relative to S->w->left_col.  */
  2445       r.x = WINDOW_LEFT_EDGE_X (s->w);
  2446       if (s->row->mode_line_p)
  2447         r.width = WINDOW_PIXEL_WIDTH (s->w) - WINDOW_RIGHT_DIVIDER_WIDTH (s->w);
  2448       else
  2449         r.width = WINDOW_PIXEL_WIDTH (s->w);
  2450 
  2451       /* Unless displaying a mode or menu bar line, which are always
  2452          fully visible, clip to the visible part of the row.  */
  2453       if (s->w->pseudo_window_p)
  2454         r.height = s->row->visible_height;
  2455       else
  2456         r.height = s->height;
  2457     }
  2458   else
  2459     {
  2460       /* This is a text line that may be partially visible.  */
  2461       r.x = window_box_left (s->w, s->area);
  2462       r.width = window_box_width (s->w, s->area);
  2463       r.height = s->row->visible_height;
  2464     }
  2465 
  2466   if (s->clip_head)
  2467     if (r.x < s->clip_head->x)
  2468       {
  2469         if (r.width >= s->clip_head->x - r.x)
  2470           r.width -= s->clip_head->x - r.x;
  2471         else
  2472           r.width = 0;
  2473         r.x = s->clip_head->x;
  2474       }
  2475   if (s->clip_tail)
  2476     if (r.x + r.width > s->clip_tail->x + s->clip_tail->background_width)
  2477       {
  2478         if (s->clip_tail->x + s->clip_tail->background_width >= r.x)
  2479           r.width = s->clip_tail->x + s->clip_tail->background_width - r.x;
  2480         else
  2481           r.width = 0;
  2482       }
  2483 
  2484   /* If S draws overlapping rows, it's sufficient to use the top and
  2485      bottom of the window for clipping because this glyph string
  2486      intentionally draws over other lines.  */
  2487   if (s->for_overlaps)
  2488     {
  2489       r.y = WINDOW_TAB_LINE_HEIGHT (s->w) + WINDOW_HEADER_LINE_HEIGHT (s->w);
  2490       r.height = window_text_bottom_y (s->w) - r.y;
  2491 
  2492       /* Alas, the above simple strategy does not work for the
  2493          environments with anti-aliased text: if the same text is
  2494          drawn onto the same place multiple times, it gets thicker.
  2495          If the overlap we are processing is for the erased cursor, we
  2496          take the intersection with the rectangle of the cursor.  */
  2497       if (s->for_overlaps & OVERLAPS_ERASED_CURSOR)
  2498         {
  2499           Emacs_Rectangle rc, r_save = r;
  2500 
  2501           rc.x = WINDOW_TEXT_TO_FRAME_PIXEL_X (s->w, s->w->phys_cursor.x);
  2502           rc.y = s->w->phys_cursor.y;
  2503           rc.width = s->w->phys_cursor_width;
  2504           rc.height = s->w->phys_cursor_height;
  2505 
  2506           gui_intersect_rectangles (&r_save, &rc, &r);
  2507         }
  2508     }
  2509   else
  2510     {
  2511       /* Don't use S->y for clipping because it doesn't take partially
  2512          visible lines into account.  For example, it can be negative for
  2513          partially visible lines at the top of a window.  */
  2514       if (!s->row->full_width_p
  2515           && MATRIX_ROW_PARTIALLY_VISIBLE_AT_TOP_P (s->w, s->row))
  2516         r.y = WINDOW_TAB_LINE_HEIGHT (s->w) + WINDOW_HEADER_LINE_HEIGHT (s->w);
  2517       else
  2518         r.y = max (0, s->row->y);
  2519     }
  2520 
  2521   r.y = WINDOW_TO_FRAME_PIXEL_Y (s->w, r.y);
  2522 
  2523   /* If drawing the cursor, don't let glyph draw outside its
  2524      advertised boundaries. Cleartype does this under some circumstances.  */
  2525   if (s->hl == DRAW_CURSOR)
  2526     {
  2527       struct glyph *glyph = s->first_glyph;
  2528       int height, max_y;
  2529 
  2530       if (s->x > r.x)
  2531         {
  2532           if (r.width >= s->x - r.x)
  2533             r.width -= s->x - r.x;
  2534           else  /* R2L hscrolled row with cursor outside text area */
  2535             r.width = 0;
  2536           r.x = s->x;
  2537         }
  2538       r.width = min (r.width, glyph->pixel_width);
  2539 
  2540       /* If r.y is below window bottom, ensure that we still see a cursor.  */
  2541       height = min (glyph->ascent + glyph->descent,
  2542                     min (FRAME_LINE_HEIGHT (s->f), s->row->visible_height));
  2543       max_y = window_text_bottom_y (s->w) - height;
  2544       max_y = WINDOW_TO_FRAME_PIXEL_Y (s->w, max_y);
  2545       if (s->ybase - glyph->ascent > max_y)
  2546         {
  2547           r.y = max_y;
  2548           r.height = height;
  2549         }
  2550       else
  2551         {
  2552           /* Don't draw cursor glyph taller than our actual glyph.  */
  2553           height = max (FRAME_LINE_HEIGHT (s->f), glyph->ascent + glyph->descent);
  2554           if (height < r.height)
  2555             {
  2556               max_y = r.y + r.height;
  2557               r.y = min (max_y, max (r.y, s->ybase + glyph->descent - height));
  2558               r.height = min (max_y - r.y, height);
  2559             }
  2560         }
  2561     }
  2562 
  2563   if (s->row->clip)
  2564     {
  2565       Emacs_Rectangle r_save = r;
  2566 
  2567       if (! gui_intersect_rectangles (&r_save, s->row->clip, &r))
  2568         r.width = 0;
  2569     }
  2570 
  2571   if ((s->for_overlaps & OVERLAPS_BOTH) == 0
  2572       || ((s->for_overlaps & OVERLAPS_BOTH) == OVERLAPS_BOTH && n == 1))
  2573     {
  2574 #ifdef CONVERT_FROM_EMACS_RECT
  2575       CONVERT_FROM_EMACS_RECT (r, *rects);
  2576 #else
  2577       *rects = r;
  2578 #endif
  2579       return 1;
  2580     }
  2581   else
  2582     {
  2583       /* If we are processing overlapping and allowed to return
  2584          multiple clipping rectangles, we exclude the row of the glyph
  2585          string from the clipping rectangle.  This is to avoid drawing
  2586          the same text on the environment with anti-aliasing.  */
  2587 #ifdef CONVERT_FROM_EMACS_RECT
  2588       Emacs_Rectangle rs[2];
  2589 #else
  2590       Emacs_Rectangle *rs = rects;
  2591 #endif
  2592       int i = 0, row_y = WINDOW_TO_FRAME_PIXEL_Y (s->w, s->row->y);
  2593 
  2594       if (s->for_overlaps & OVERLAPS_PRED)
  2595         {
  2596           rs[i] = r;
  2597           if (r.y + r.height > row_y)
  2598             {
  2599               if (r.y < row_y)
  2600                 rs[i].height = row_y - r.y;
  2601               else
  2602                 rs[i].height = 0;
  2603             }
  2604           i++;
  2605         }
  2606       if (s->for_overlaps & OVERLAPS_SUCC)
  2607         {
  2608           rs[i] = r;
  2609           if (r.y < row_y + s->row->visible_height)
  2610             {
  2611               if (r.y + r.height > row_y + s->row->visible_height)
  2612                 {
  2613                   rs[i].y = row_y + s->row->visible_height;
  2614                   rs[i].height = r.y + r.height - rs[i].y;
  2615                 }
  2616               else
  2617                 rs[i].height = 0;
  2618             }
  2619           i++;
  2620         }
  2621 
  2622       n = i;
  2623 #ifdef CONVERT_FROM_EMACS_RECT
  2624       for (i = 0; i < n; i++)
  2625         CONVERT_FROM_EMACS_RECT (rs[i], rects[i]);
  2626 #endif
  2627       return n;
  2628     }
  2629 }
  2630 
  2631 /* EXPORT:
  2632    Return in *NR the clipping rectangle for glyph string S.  */
  2633 
  2634 void
  2635 get_glyph_string_clip_rect (struct glyph_string *s, NativeRectangle *nr)
  2636 {
  2637   get_glyph_string_clip_rects (s, nr, 1);
  2638 }
  2639 
  2640 
  2641 /* EXPORT:
  2642    Return the position and height of the phys cursor in window W.
  2643    Set w->phys_cursor_width to width of phys cursor.
  2644 */
  2645 
  2646 void
  2647 get_phys_cursor_geometry (struct window *w, struct glyph_row *row,
  2648                           struct glyph *glyph, int *xp, int *yp, int *heightp)
  2649 {
  2650   struct frame *f = XFRAME (WINDOW_FRAME (w));
  2651   int x, y, wd, h, h0, y0, ascent;
  2652 
  2653   /* Compute the width of the rectangle to draw.  If on a stretch
  2654      glyph, and `x-stretch-cursor' is nil, don't draw a rectangle
  2655      as wide as the glyph, but use a canonical character width
  2656      instead.  */
  2657   wd = glyph->pixel_width;
  2658 
  2659   x = w->phys_cursor.x;
  2660   if (x < 0)
  2661     {
  2662       wd += x;
  2663       x = 0;
  2664     }
  2665 
  2666   if (glyph->type == STRETCH_GLYPH
  2667       && !x_stretch_cursor_p)
  2668     wd = min (FRAME_COLUMN_WIDTH (f), wd);
  2669   w->phys_cursor_width = wd;
  2670 
  2671   /* Don't let the hollow cursor glyph descend below the glyph row's
  2672      ascent value, lest the hollow cursor looks funny.  */
  2673   y = w->phys_cursor.y;
  2674   ascent = row->ascent;
  2675   /* The test for row at ZV is for when line numbers are displayed and
  2676      point is at EOB: the cursor could then be smaller or larger than
  2677      the default face's font.  */
  2678   if (!row->ends_at_zv_p && row->ascent < glyph->ascent)
  2679     {
  2680       y -= glyph->ascent - row->ascent;
  2681       ascent = glyph->ascent;
  2682     }
  2683 
  2684   /* If y is below window bottom, ensure that we still see a cursor.  */
  2685   h0 = min (FRAME_LINE_HEIGHT (f), row->visible_height);
  2686 
  2687   h = max (h0, ascent + glyph->descent);
  2688   /* Don't let the cursor exceed the dimensions of the row, so that
  2689      the upper/lower side of the box aren't clipped.  */
  2690   h = min (h, row->height);
  2691   h0 = min (h0, ascent + glyph->descent);
  2692 
  2693   y0 = WINDOW_TAB_LINE_HEIGHT (w) + WINDOW_HEADER_LINE_HEIGHT (w);
  2694   if (y < y0)
  2695     {
  2696       h = max (h - (y0 - y) + 1, h0);
  2697       y = y0 - 1;
  2698     }
  2699   else
  2700     {
  2701       y0 = window_text_bottom_y (w) - h0;
  2702       if (y > y0)
  2703         {
  2704           h += y - y0;
  2705           y = y0;
  2706         }
  2707     }
  2708 
  2709   *xp = WINDOW_TEXT_TO_FRAME_PIXEL_X (w, x);
  2710   *yp = WINDOW_TO_FRAME_PIXEL_Y (w, y);
  2711   *heightp = h;
  2712 }
  2713 
  2714 /*
  2715  * Remember which glyph the mouse is over.
  2716  */
  2717 
  2718 void
  2719 remember_mouse_glyph (struct frame *f, int gx, int gy, NativeRectangle *rect)
  2720 {
  2721   Lisp_Object window;
  2722   struct window *w;
  2723   struct glyph_row *r, *gr, *end_row;
  2724   enum window_part part;
  2725   enum glyph_row_area area;
  2726   int x, y, width, height;
  2727 
  2728   if (mouse_fine_grained_tracking)
  2729     {
  2730       STORE_NATIVE_RECT (*rect, gx, gy, 1, 1);
  2731       return;
  2732     }
  2733 
  2734   /* Try to determine frame pixel position and size of the glyph under
  2735      frame pixel coordinates X/Y on frame F.  */
  2736 
  2737   if (window_resize_pixelwise)
  2738     {
  2739       width = height = 1;
  2740       goto virtual_glyph;
  2741     }
  2742   else if (!f->glyphs_initialized_p
  2743            || (window = window_from_coordinates (f, gx, gy, &part, false, false),
  2744                NILP (window)))
  2745     {
  2746       width = FRAME_SMALLEST_CHAR_WIDTH (f);
  2747       height = FRAME_SMALLEST_FONT_HEIGHT (f);
  2748       goto virtual_glyph;
  2749     }
  2750 
  2751   w = XWINDOW (window);
  2752   width = WINDOW_FRAME_COLUMN_WIDTH (w);
  2753   height = WINDOW_FRAME_LINE_HEIGHT (w);
  2754 
  2755   x = window_relative_x_coord (w, part, gx);
  2756   y = gy - WINDOW_TOP_EDGE_Y (w);
  2757 
  2758   r = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
  2759   end_row = MATRIX_BOTTOM_TEXT_ROW (w->current_matrix, w);
  2760 
  2761   if (w->pseudo_window_p)
  2762     {
  2763       area = TEXT_AREA;
  2764       part = ON_MODE_LINE; /* Don't adjust margin. */
  2765       goto text_glyph;
  2766     }
  2767 
  2768   switch (part)
  2769     {
  2770     case ON_LEFT_MARGIN:
  2771       area = LEFT_MARGIN_AREA;
  2772       goto text_glyph;
  2773 
  2774     case ON_RIGHT_MARGIN:
  2775       area = RIGHT_MARGIN_AREA;
  2776       goto text_glyph;
  2777 
  2778     case ON_TAB_LINE:
  2779     case ON_HEADER_LINE:
  2780     case ON_MODE_LINE:
  2781       gr = (part == ON_TAB_LINE
  2782             ? MATRIX_TAB_LINE_ROW (w->current_matrix)
  2783             : (part == ON_HEADER_LINE
  2784                ? MATRIX_HEADER_LINE_ROW (w->current_matrix)
  2785                : MATRIX_MODE_LINE_ROW (w->current_matrix)));
  2786       gy = gr->y;
  2787       area = TEXT_AREA;
  2788       goto text_glyph_row_found;
  2789 
  2790     case ON_TEXT:
  2791       area = TEXT_AREA;
  2792 
  2793     text_glyph:
  2794       gr = 0; gy = 0;
  2795       for (; r <= end_row && r->enabled_p; ++r)
  2796         if (r->y + r->height > y)
  2797           {
  2798             gr = r; gy = r->y;
  2799             break;
  2800           }
  2801 
  2802     text_glyph_row_found:
  2803       if (gr && gy <= y)
  2804         {
  2805           struct glyph *g = gr->glyphs[area];
  2806           struct glyph *end = g + gr->used[area];
  2807 
  2808           height = gr->height;
  2809           for (gx = gr->x; g < end; gx += g->pixel_width, ++g)
  2810             if (gx + g->pixel_width > x)
  2811               break;
  2812 
  2813           if (g < end)
  2814             {
  2815               if (g->type == IMAGE_GLYPH)
  2816                 {
  2817                   /* Don't remember when mouse is over image, as
  2818                      image may have hot-spots.  */
  2819                   STORE_NATIVE_RECT (*rect, 0, 0, 0, 0);
  2820                   return;
  2821                 }
  2822               width = g->pixel_width;
  2823             }
  2824           else
  2825             {
  2826               /* Use nominal char spacing at end of line.  */
  2827               x -= gx;
  2828               gx += (x / width) * width;
  2829             }
  2830 
  2831           if (part != ON_MODE_LINE && part != ON_HEADER_LINE
  2832               && part != ON_TAB_LINE)
  2833             {
  2834               gx += window_box_left_offset (w, area);
  2835               /* Don't expand over the modeline to make sure the vertical
  2836                  drag cursor is shown early enough.  */
  2837               height = min (height,
  2838                             max (0, WINDOW_BOX_HEIGHT_NO_MODE_LINE (w) - gy));
  2839             }
  2840         }
  2841       else
  2842         {
  2843           /* Use nominal line height at end of window.  */
  2844           gx = (x / width) * width;
  2845           y -= gy;
  2846           gy += (y / height) * height;
  2847           if (part != ON_MODE_LINE && part != ON_HEADER_LINE
  2848               && part != ON_TAB_LINE)
  2849             /* See comment above.  */
  2850             height = min (height,
  2851                           max (0, WINDOW_BOX_HEIGHT_NO_MODE_LINE (w) - gy));
  2852         }
  2853       break;
  2854 
  2855     case ON_LEFT_FRINGE:
  2856       gx = (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
  2857             ? WINDOW_LEFT_SCROLL_BAR_AREA_WIDTH (w)
  2858             : window_box_right_offset (w, LEFT_MARGIN_AREA));
  2859       width = WINDOW_LEFT_FRINGE_WIDTH (w);
  2860       goto row_glyph;
  2861 
  2862     case ON_RIGHT_FRINGE:
  2863       gx = (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
  2864             ? window_box_right_offset (w, RIGHT_MARGIN_AREA)
  2865             : window_box_right_offset (w, TEXT_AREA));
  2866       if (WINDOW_RIGHT_DIVIDER_WIDTH (w) == 0
  2867           && !WINDOW_HAS_VERTICAL_SCROLL_BAR (w)
  2868           && !WINDOW_RIGHTMOST_P (w))
  2869         if (gx < WINDOW_PIXEL_WIDTH (w) - width)
  2870           /* Make sure the vertical border can get her own glyph to the
  2871              right of the one we build here.  */
  2872           width = WINDOW_RIGHT_FRINGE_WIDTH (w) - width;
  2873         else
  2874           width = WINDOW_PIXEL_WIDTH (w) - gx;
  2875       else
  2876         width = WINDOW_RIGHT_FRINGE_WIDTH (w);
  2877 
  2878       goto row_glyph;
  2879 
  2880     case ON_VERTICAL_BORDER:
  2881       gx = WINDOW_PIXEL_WIDTH (w) - width;
  2882       goto row_glyph;
  2883 
  2884     case ON_VERTICAL_SCROLL_BAR:
  2885       gx = (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w)
  2886             ? 0
  2887             : (window_box_right_offset (w, RIGHT_MARGIN_AREA)
  2888                + (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
  2889                   ? WINDOW_RIGHT_FRINGE_WIDTH (w)
  2890                   : 0)));
  2891       width = WINDOW_SCROLL_BAR_AREA_WIDTH (w);
  2892 
  2893     row_glyph:
  2894       gr = 0, gy = 0;
  2895       for (; r <= end_row && r->enabled_p; ++r)
  2896         if (r->y + r->height > y)
  2897           {
  2898             gr = r; gy = r->y;
  2899             break;
  2900           }
  2901 
  2902       if (gr && gy <= y)
  2903         height = gr->height;
  2904       else
  2905         {
  2906           /* Use nominal line height at end of window.  */
  2907           y -= gy;
  2908           gy += (y / height) * height;
  2909         }
  2910       break;
  2911 
  2912     case ON_RIGHT_DIVIDER:
  2913       gx = WINDOW_PIXEL_WIDTH (w) - WINDOW_RIGHT_DIVIDER_WIDTH (w);
  2914       width = WINDOW_RIGHT_DIVIDER_WIDTH (w);
  2915       gy = 0;
  2916       /* The bottom divider prevails. */
  2917       height = WINDOW_PIXEL_HEIGHT (w) - WINDOW_BOTTOM_DIVIDER_WIDTH (w);
  2918       goto add_edge;
  2919 
  2920     case ON_BOTTOM_DIVIDER:
  2921       gx = 0;
  2922       width = WINDOW_PIXEL_WIDTH (w);
  2923       gy = WINDOW_PIXEL_HEIGHT (w) - WINDOW_BOTTOM_DIVIDER_WIDTH (w);
  2924       height = WINDOW_BOTTOM_DIVIDER_WIDTH (w);
  2925       goto add_edge;
  2926 
  2927     default:
  2928       ;
  2929     virtual_glyph:
  2930       /* If there is no glyph under the mouse, then we divide the screen
  2931          into a grid of the smallest glyph in the frame, and use that
  2932          as our "glyph".  */
  2933 
  2934       /* Arrange for the division in FRAME_PIXEL_X_TO_COL etc. to
  2935          round down even for negative values.  */
  2936       if (gx < 0)
  2937         gx -= width - 1;
  2938       if (gy < 0)
  2939         gy -= height - 1;
  2940 
  2941       gx = (gx / width) * width;
  2942       gy = (gy / height) * height;
  2943 
  2944       goto store_rect;
  2945     }
  2946 
  2947  add_edge:
  2948   gx += WINDOW_LEFT_EDGE_X (w);
  2949   gy += WINDOW_TOP_EDGE_Y (w);
  2950 
  2951  store_rect:
  2952   STORE_NATIVE_RECT (*rect, gx, gy, width, height);
  2953 
  2954   /* Visible feedback for debugging.  */
  2955 #if false && defined HAVE_X_WINDOWS
  2956   XDrawRectangle (FRAME_X_DISPLAY (f), FRAME_X_DRAWABLE (f),
  2957                   f->output_data.x->normal_gc,
  2958                   gx, gy, width, height);
  2959 #endif
  2960 }
  2961 
  2962 
  2963 #endif /* HAVE_WINDOW_SYSTEM */
  2964 
  2965 static void
  2966 adjust_window_ends (struct window *w, struct glyph_row *row, bool current)
  2967 {
  2968   eassert (w);
  2969   w->window_end_pos = Z - MATRIX_ROW_END_CHARPOS (row);
  2970   w->window_end_bytepos = Z_BYTE - MATRIX_ROW_END_BYTEPOS (row);
  2971   w->window_end_vpos
  2972     = MATRIX_ROW_VPOS (row, current ? w->current_matrix : w->desired_matrix);
  2973 }
  2974 
  2975 static bool
  2976 hscrolling_current_line_p (struct window *w)
  2977 {
  2978   return (!w->suspend_auto_hscroll
  2979           && EQ (Fbuffer_local_value (Qauto_hscroll_mode, w->contents),
  2980                  Qcurrent_line));
  2981 }
  2982 
  2983 /***********************************************************************
  2984                         Lisp form evaluation
  2985  ***********************************************************************/
  2986 
  2987 /* Error handler for safe_eval and safe_call.  */
  2988 
  2989 static Lisp_Object
  2990 safe_eval_handler (Lisp_Object arg, ptrdiff_t nargs, Lisp_Object *args)
  2991 {
  2992   add_to_log ("Error during redisplay: %S signaled %S",
  2993               Flist (nargs, args), arg);
  2994   return Qnil;
  2995 }
  2996 
  2997 /* Call function FUNC with the rest of NARGS - 1 arguments
  2998    following.  Return the result, or nil if something went
  2999    wrong.  Prevent redisplay during the evaluation.  */
  3000 
  3001 static Lisp_Object
  3002 safe__call (bool inhibit_quit, ptrdiff_t nargs, Lisp_Object func, va_list ap)
  3003 {
  3004   Lisp_Object val;
  3005 
  3006   if (inhibit_eval_during_redisplay)
  3007     val = Qnil;
  3008   else
  3009     {
  3010       ptrdiff_t i;
  3011       specpdl_ref count = SPECPDL_INDEX ();
  3012       Lisp_Object *args;
  3013       USE_SAFE_ALLOCA;
  3014       SAFE_ALLOCA_LISP (args, nargs);
  3015 
  3016       args[0] = func;
  3017       for (i = 1; i < nargs; i++)
  3018         args[i] = va_arg (ap, Lisp_Object);
  3019 
  3020       specbind (Qinhibit_redisplay, Qt);
  3021       if (inhibit_quit)
  3022         specbind (Qinhibit_quit, Qt);
  3023       /* Use Qt to ensure debugger does not run,
  3024          so there is no possibility of wanting to redisplay.  */
  3025       val = internal_condition_case_n (Ffuncall, nargs, args, Qt,
  3026                                        safe_eval_handler);
  3027       val = SAFE_FREE_UNBIND_TO (count, val);
  3028     }
  3029 
  3030   return val;
  3031 }
  3032 
  3033 Lisp_Object
  3034 safe_call (ptrdiff_t nargs, Lisp_Object func, ...)
  3035 {
  3036   Lisp_Object retval;
  3037   va_list ap;
  3038 
  3039   va_start (ap, func);
  3040   retval = safe__call (false, nargs, func, ap);
  3041   va_end (ap);
  3042   return retval;
  3043 }
  3044 
  3045 /* Call function FN with one argument ARG.
  3046    Return the result, or nil if something went wrong.  */
  3047 
  3048 Lisp_Object
  3049 safe_call1 (Lisp_Object fn, Lisp_Object arg)
  3050 {
  3051   return safe_call (2, fn, arg);
  3052 }
  3053 
  3054 static Lisp_Object
  3055 safe__call1 (bool inhibit_quit, Lisp_Object fn, ...)
  3056 {
  3057   Lisp_Object retval;
  3058   va_list ap;
  3059 
  3060   va_start (ap, fn);
  3061   retval = safe__call (inhibit_quit, 2, fn, ap);
  3062   va_end (ap);
  3063   return retval;
  3064 }
  3065 
  3066 Lisp_Object
  3067 safe_eval (Lisp_Object sexpr)
  3068 {
  3069   return safe__call1 (false, Qeval, sexpr);
  3070 }
  3071 
  3072 static Lisp_Object
  3073 safe__eval (bool inhibit_quit, Lisp_Object sexpr)
  3074 {
  3075   return safe__call1 (inhibit_quit, Qeval, sexpr);
  3076 }
  3077 
  3078 /* Call function FN with two arguments ARG1 and ARG2.
  3079    Return the result, or nil if something went wrong.  */
  3080 
  3081 Lisp_Object
  3082 safe_call2 (Lisp_Object fn, Lisp_Object arg1, Lisp_Object arg2)
  3083 {
  3084   return safe_call (3, fn, arg1, arg2);
  3085 }
  3086 
  3087 
  3088 
  3089 /***********************************************************************
  3090                               Debugging
  3091  ***********************************************************************/
  3092 
  3093 /* Define CHECK_IT to perform sanity checks on iterators.
  3094    This is for debugging.  It is too slow to do unconditionally.  */
  3095 
  3096 static void
  3097 CHECK_IT (struct it *it)
  3098 {
  3099 #if false
  3100   if (it->method == GET_FROM_STRING)
  3101     {
  3102       eassert (STRINGP (it->string));
  3103       eassert (IT_STRING_CHARPOS (*it) >= 0);
  3104     }
  3105   else
  3106     {
  3107       eassert (IT_STRING_CHARPOS (*it) < 0);
  3108       if (it->method == GET_FROM_BUFFER)
  3109         {
  3110           /* Check that character and byte positions agree.  */
  3111           eassert (IT_CHARPOS (*it) == BYTE_TO_CHAR (IT_BYTEPOS (*it)));
  3112         }
  3113     }
  3114 
  3115   if (it->dpvec)
  3116     eassert (it->current.dpvec_index >= 0);
  3117   else
  3118     eassert (it->current.dpvec_index < 0);
  3119 #endif
  3120 }
  3121 
  3122 
  3123 /* Check that the window end of window W is what we expect it
  3124    to be---the last row in the current matrix displaying text.  */
  3125 
  3126 static void
  3127 CHECK_WINDOW_END (struct window *w)
  3128 {
  3129 #if defined GLYPH_DEBUG && defined ENABLE_CHECKING
  3130   if (!MINI_WINDOW_P (w) && w->window_end_valid)
  3131     {
  3132       struct glyph_row *row;
  3133       eassert ((row = MATRIX_ROW (w->current_matrix, w->window_end_vpos),
  3134                 !row->enabled_p
  3135                 || MATRIX_ROW_DISPLAYS_TEXT_P (row)
  3136                 || MATRIX_ROW_VPOS (row, w->current_matrix) == 0));
  3137     }
  3138 #endif
  3139 }
  3140 
  3141 /***********************************************************************
  3142                        Iterator initialization
  3143  ***********************************************************************/
  3144 
  3145 /* Initialize IT for displaying current_buffer in window W, starting
  3146    at character position CHARPOS.  CHARPOS < 0 means that no buffer
  3147    position is specified which is useful when the iterator is assigned
  3148    a position later.  BYTEPOS is the byte position corresponding to
  3149    CHARPOS.
  3150 
  3151    If ROW is not null, calls to produce_glyphs with IT as parameter
  3152    will produce glyphs in that row.
  3153 
  3154    BASE_FACE_ID is the id of a base face to use.  It must be one of
  3155    DEFAULT_FACE_ID for normal text, MODE_LINE_ACTIVE_FACE_ID,
  3156    MODE_LINE_INACTIVE_FACE_ID, or HEADER_LINE_FACE_ID for displaying
  3157    mode lines, or TOOL_BAR_FACE_ID for displaying the tool-bar.
  3158 
  3159    If ROW is null and BASE_FACE_ID is equal to MODE_LINE_ACTIVE_FACE_ID,
  3160    MODE_LINE_INACTIVE_FACE_ID, or HEADER_LINE_FACE_ID, the iterator
  3161    will be initialized to use the corresponding mode line glyph row of
  3162    the desired matrix of W.  */
  3163 
  3164 void
  3165 init_iterator (struct it *it, struct window *w,
  3166                ptrdiff_t charpos, ptrdiff_t bytepos,
  3167                struct glyph_row *row, enum face_id base_face_id)
  3168 {
  3169   enum face_id remapped_base_face_id = base_face_id;
  3170   int body_width = 0, body_height = 0;
  3171 
  3172   /* Some precondition checks.  */
  3173   eassert (w != NULL && it != NULL);
  3174   eassert (charpos < 0 || (charpos >= BUF_BEG (current_buffer)
  3175                            && charpos <= ZV));
  3176 
  3177   /* If face attributes have been changed since the last redisplay,
  3178      free realized faces now because they depend on face definitions
  3179      that might have changed.  Don't free faces while there might be
  3180      desired matrices pending which reference these faces.  */
  3181   if (!inhibit_free_realized_faces)
  3182     {
  3183       if (face_change)
  3184         {
  3185           face_change = false;
  3186           XFRAME (w->frame)->face_change = 0;
  3187           free_all_realized_faces (Qnil);
  3188         }
  3189       else if (XFRAME (w->frame)->face_change)
  3190         {
  3191           XFRAME (w->frame)->face_change = 0;
  3192           free_all_realized_faces (w->frame);
  3193         }
  3194     }
  3195 
  3196   /* Perhaps remap BASE_FACE_ID to a user-specified alternative.  */
  3197   if (! NILP (Vface_remapping_alist))
  3198     remapped_base_face_id
  3199       = lookup_basic_face (w, XFRAME (w->frame), base_face_id);
  3200 
  3201   /* Use one of the mode line rows of W's desired matrix if
  3202      appropriate.  */
  3203   if (row == NULL)
  3204     {
  3205       if (base_face_id == MODE_LINE_ACTIVE_FACE_ID
  3206           || base_face_id == MODE_LINE_INACTIVE_FACE_ID)
  3207         row = MATRIX_MODE_LINE_ROW (w->desired_matrix);
  3208       else if (base_face_id == TAB_LINE_FACE_ID)
  3209         row = MATRIX_TAB_LINE_ROW (w->desired_matrix);
  3210       else if (base_face_id == HEADER_LINE_FACE_ID)
  3211         {
  3212           /* Header line row depends on whether tab line is enabled.  */
  3213           w->desired_matrix->tab_line_p = window_wants_tab_line (w);
  3214           row = MATRIX_HEADER_LINE_ROW (w->desired_matrix);
  3215         }
  3216     }
  3217 
  3218   /* Clear IT, and set it->object and other IT's Lisp objects to Qnil.
  3219      Other parts of redisplay rely on that.  */
  3220   memclear (it, sizeof *it);
  3221   it->current.overlay_string_index = -1;
  3222   it->current.dpvec_index = -1;
  3223   it->base_face_id = remapped_base_face_id;
  3224   IT_STRING_CHARPOS (*it) = IT_STRING_BYTEPOS (*it) = -1;
  3225   it->paragraph_embedding = L2R;
  3226   it->bidi_it.w = w;
  3227 
  3228   /* The window in which we iterate over current_buffer:  */
  3229   XSETWINDOW (it->window, w);
  3230   it->w = w;
  3231   it->f = XFRAME (w->frame);
  3232 
  3233   it->cmp_it.id = -1;
  3234   it->cmp_it.parent_it = it;
  3235 
  3236   if (max_redisplay_ticks > 0)
  3237     update_redisplay_ticks (0, w);
  3238 
  3239   /* Extra space between lines (on window systems only).  */
  3240   if (base_face_id == DEFAULT_FACE_ID
  3241       && FRAME_WINDOW_P (it->f))
  3242     {
  3243       if (FIXNATP (BVAR (current_buffer, extra_line_spacing)))
  3244         it->extra_line_spacing = XFIXNAT (BVAR (current_buffer, extra_line_spacing));
  3245       else if (FLOATP (BVAR (current_buffer, extra_line_spacing)))
  3246         it->extra_line_spacing = (XFLOAT_DATA (BVAR (current_buffer, extra_line_spacing))
  3247                                   * FRAME_LINE_HEIGHT (it->f));
  3248       else if (it->f->extra_line_spacing > 0)
  3249         it->extra_line_spacing = it->f->extra_line_spacing;
  3250     }
  3251 
  3252   /* If realized faces have been removed, e.g. because of face
  3253      attribute changes of named faces, recompute them.  When running
  3254      in batch mode, the face cache of the initial frame is null.  If
  3255      we happen to get called, make a dummy face cache.  */
  3256   if (FRAME_FACE_CACHE (it->f) == NULL)
  3257     init_frame_faces (it->f);
  3258   if (FRAME_FACE_CACHE (it->f)->used == 0)
  3259     recompute_basic_faces (it->f);
  3260 
  3261   it->override_ascent = -1;
  3262 
  3263   /* Are control characters displayed as `^C'?  */
  3264   it->ctl_arrow_p = !NILP (BVAR (current_buffer, ctl_arrow));
  3265 
  3266   /* -1 means everything between a CR and the following line end
  3267      is invisible.  >0 means lines indented more than this value are
  3268      invisible.  */
  3269   it->selective = (FIXNUMP (BVAR (current_buffer, selective_display))
  3270                    ? (clip_to_bounds
  3271                       (-1, XFIXNUM (BVAR (current_buffer, selective_display)),
  3272                        PTRDIFF_MAX))
  3273                    : (!NILP (BVAR (current_buffer, selective_display))
  3274                       ? -1 : 0));
  3275   it->selective_display_ellipsis_p
  3276     = !NILP (BVAR (current_buffer, selective_display_ellipses));
  3277 
  3278   /* Display table to use.  */
  3279   it->dp = window_display_table (w);
  3280 
  3281   /* Are multibyte characters enabled in current_buffer?  */
  3282   it->multibyte_p = !NILP (BVAR (current_buffer, enable_multibyte_characters));
  3283 
  3284   it->tab_width = SANE_TAB_WIDTH (current_buffer);
  3285 
  3286   /* Are lines in the display truncated?  */
  3287   if (TRUNCATE != 0)
  3288     it->line_wrap = TRUNCATE;
  3289   if (base_face_id == DEFAULT_FACE_ID
  3290       && !it->w->hscroll
  3291       && (WINDOW_FULL_WIDTH_P (it->w)
  3292           || NILP (Vtruncate_partial_width_windows)
  3293           || (FIXNUMP (Vtruncate_partial_width_windows)
  3294               /* PXW: Shall we do something about this?  */
  3295               && (XFIXNUM (Vtruncate_partial_width_windows)
  3296                   <= WINDOW_TOTAL_COLS (it->w))))
  3297       && NILP (BVAR (current_buffer, truncate_lines)))
  3298     it->line_wrap = NILP (BVAR (current_buffer, word_wrap))
  3299       ? WINDOW_WRAP : WORD_WRAP;
  3300 
  3301   /* Get dimensions of truncation and continuation glyphs.  These are
  3302      displayed as fringe bitmaps under X, but we need them for such
  3303      frames when the fringes are turned off.  The no_special_glyphs slot
  3304      of the iterator's frame, when set, suppresses their display - by
  3305      default for tooltip frames and when set via the 'no-special-glyphs'
  3306      frame parameter.  */
  3307 #ifdef HAVE_WINDOW_SYSTEM
  3308   if (!(FRAME_WINDOW_P (it->f) && it->f->no_special_glyphs))
  3309 #endif
  3310     {
  3311       if (it->line_wrap == TRUNCATE)
  3312         {
  3313           /* We will need the truncation glyph.  */
  3314           eassert (it->glyph_row == NULL);
  3315           produce_special_glyphs (it, IT_TRUNCATION);
  3316           it->truncation_pixel_width = it->pixel_width;
  3317         }
  3318       else
  3319         {
  3320           /* We will need the continuation glyph.  */
  3321           eassert (it->glyph_row == NULL);
  3322           produce_special_glyphs (it, IT_CONTINUATION);
  3323           it->continuation_pixel_width = it->pixel_width;
  3324         }
  3325     }
  3326 
  3327   /* Reset these values to zero because the produce_special_glyphs
  3328      above has changed them.  */
  3329   it->pixel_width = it->ascent = it->descent = 0;
  3330   it->phys_ascent = it->phys_descent = 0;
  3331 
  3332   /* Set this after getting the dimensions of truncation and
  3333      continuation glyphs, so that we don't produce glyphs when calling
  3334      produce_special_glyphs, above.  */
  3335   it->glyph_row = row;
  3336   it->area = TEXT_AREA;
  3337 
  3338   /* Get the dimensions of the display area.  The display area
  3339      consists of the visible window area plus a horizontally scrolled
  3340      part to the left of the window.  All x-values are relative to the
  3341      start of this total display area.  */
  3342   if (base_face_id != DEFAULT_FACE_ID)
  3343     {
  3344       /* Mode lines, menu bar in terminal frames.  */
  3345       it->first_visible_x = 0;
  3346       it->last_visible_x =
  3347         WINDOW_PIXEL_WIDTH (w) - WINDOW_RIGHT_DIVIDER_WIDTH (w);
  3348     }
  3349   else
  3350     {
  3351       /* When hscrolling only the current line, don't apply the
  3352          hscroll here, it will be applied by display_line when it gets
  3353          to laying out the line showing point.  However, if the
  3354          window's min_hscroll is positive, the user specified a lower
  3355          bound for automatic hscrolling, so they expect the
  3356          non-current lines to obey that hscroll amount.  */
  3357       if (hscrolling_current_line_p (w))
  3358         {
  3359           if (w->min_hscroll > 0)
  3360             it->first_visible_x = w->min_hscroll * FRAME_COLUMN_WIDTH (it->f);
  3361           else
  3362             it->first_visible_x = 0;
  3363         }
  3364       else
  3365         it->first_visible_x =
  3366           window_hscroll_limited (w, it->f) * FRAME_COLUMN_WIDTH (it->f);
  3367 
  3368       body_width = window_box_width (w, TEXT_AREA);
  3369       if (!w->pseudo_window_p && !MINI_WINDOW_P (w)
  3370           && body_width != w->old_body_pixel_width)
  3371         FRAME_WINDOW_CHANGE (it->f) = true;
  3372       it->last_visible_x = it->first_visible_x + body_width;
  3373 
  3374       /* If we truncate lines, leave room for the truncation glyph(s) at
  3375          the right margin.  Otherwise, leave room for the continuation
  3376          glyph(s).  Done only if the window has no right fringe.  */
  3377       if (WINDOW_RIGHT_FRINGE_WIDTH (it->w) == 0)
  3378         {
  3379           if (it->line_wrap == TRUNCATE)
  3380             it->last_visible_x -= it->truncation_pixel_width;
  3381           else
  3382             it->last_visible_x -= it->continuation_pixel_width;
  3383         }
  3384 
  3385       it->tab_line_p = window_wants_tab_line (w);
  3386       it->header_line_p = window_wants_header_line (w);
  3387       body_height = WINDOW_TAB_LINE_HEIGHT (w) + WINDOW_HEADER_LINE_HEIGHT (w);
  3388       it->current_y =  body_height + w->vscroll;
  3389     }
  3390 
  3391   /* Leave room for a border glyph.  */
  3392   if (!FRAME_WINDOW_P (it->f)
  3393       && !WINDOW_RIGHTMOST_P (it->w))
  3394     it->last_visible_x -= 1;
  3395 
  3396   it->last_visible_y = window_text_bottom_y (w);
  3397   body_height += it->last_visible_y;
  3398   if (!w->pseudo_window_p && !MINI_WINDOW_P (w)
  3399       && body_height != w->old_body_pixel_height)
  3400     FRAME_WINDOW_CHANGE (it->f) = true;
  3401 
  3402   /* For mode lines and alike, arrange for the first glyph having a
  3403      left box line if the face specifies a box.  */
  3404   if (base_face_id != DEFAULT_FACE_ID)
  3405     {
  3406       struct face *face;
  3407 
  3408       it->face_id = remapped_base_face_id;
  3409 
  3410       /* If we have a boxed mode line, make the first character appear
  3411          with a left box line.  */
  3412       face = FACE_FROM_ID_OR_NULL (it->f, remapped_base_face_id);
  3413       if (face && face->box != FACE_NO_BOX)
  3414         {
  3415           int box_thickness = face->box_vertical_line_width;
  3416           it->face_box_p = true;
  3417           it->start_of_box_run_p = true;
  3418           /* Make sure we will have enough horizontal space to add the
  3419              right box line at the end.  */
  3420           if (box_thickness > 0)
  3421             it->last_visible_x -= box_thickness;
  3422         }
  3423     }
  3424 
  3425   /* If a buffer position was specified, set the iterator there,
  3426      getting overlays and face properties from that position.  */
  3427   if (charpos >= BUF_BEG (current_buffer))
  3428     {
  3429       it->stop_charpos = charpos;
  3430       it->end_charpos = ZV;
  3431       eassert (charpos == BYTE_TO_CHAR (bytepos));
  3432       IT_CHARPOS (*it) = charpos;
  3433       IT_BYTEPOS (*it) = bytepos;
  3434 
  3435       /* We will rely on `reseat' to set this up properly, via
  3436          handle_face_prop.  */
  3437       it->face_id = it->base_face_id;
  3438 
  3439       it->start = it->current;
  3440       /* Do we need to reorder bidirectional text?  Not if this is a
  3441          unibyte buffer: by definition, none of the single-byte
  3442          characters are strong R2L, so no reordering is needed.  And
  3443          bidi.c doesn't support unibyte buffers anyway.  Also, don't
  3444          reorder while we are loading loadup.el, since the tables of
  3445          character properties needed for reordering are not yet
  3446          available.  */
  3447       it->bidi_p =
  3448         !redisplay__inhibit_bidi
  3449         && !NILP (BVAR (current_buffer, bidi_display_reordering))
  3450         && it->multibyte_p;
  3451 
  3452       /* If we are to reorder bidirectional text, init the bidi
  3453          iterator.  */
  3454       if (it->bidi_p)
  3455         {
  3456           /*  Since we don't know at this point whether there will be
  3457               any R2L lines in the window, we reserve space for
  3458               truncation/continuation glyphs even if only the left
  3459               fringe is absent.  */
  3460           if (base_face_id == DEFAULT_FACE_ID
  3461               && WINDOW_LEFT_FRINGE_WIDTH (it->w) == 0
  3462               && WINDOW_RIGHT_FRINGE_WIDTH (it->w) != 0)
  3463             {
  3464               if (it->line_wrap == TRUNCATE)
  3465                 it->last_visible_x -= it->truncation_pixel_width;
  3466               else
  3467                 it->last_visible_x -= it->continuation_pixel_width;
  3468             }
  3469           /* Note the paragraph direction that this buffer wants to
  3470              use.  */
  3471           if (EQ (BVAR (current_buffer, bidi_paragraph_direction),
  3472                   Qleft_to_right))
  3473             it->paragraph_embedding = L2R;
  3474           else if (EQ (BVAR (current_buffer, bidi_paragraph_direction),
  3475                        Qright_to_left))
  3476             it->paragraph_embedding = R2L;
  3477           else
  3478             it->paragraph_embedding = NEUTRAL_DIR;
  3479           bidi_unshelve_cache (NULL, false);
  3480           bidi_init_it (charpos, IT_BYTEPOS (*it), FRAME_WINDOW_P (it->f),
  3481                         &it->bidi_it);
  3482         }
  3483 
  3484       /* This is set only when long_line_optimizations_p is non-zero
  3485          for the current buffer.  */
  3486       it->medium_narrowing_begv = 0;
  3487 
  3488       /* Compute faces etc.  */
  3489       reseat (it, it->current.pos, true);
  3490     }
  3491 
  3492   CHECK_IT (it);
  3493 }
  3494 
  3495 /* How Emacs deals with long lines.
  3496 
  3497    (1) When a buffer is about to be (re)displayed, 'redisplay_window'
  3498    detects, with a heuristic, whether it contains long lines.
  3499 
  3500    This happens in 'redisplay_window' because it is only displaying
  3501    buffers with long lines that is problematic.  In other words, none
  3502    of the optimizations described below is ever used in buffers that
  3503    are never displayed.
  3504 
  3505    This happens with a heuristic, which checks whether a buffer
  3506    contains long lines, each time its contents have changed "enough"
  3507    between two redisplay cycles, because a buffer without long lines
  3508    can become a buffer with long lines at any time, for example after
  3509    a yank command, or after a replace command, or while the output of
  3510    an external process is inserted in a buffer.
  3511 
  3512    When Emacs has detected that a buffer contains long lines, the
  3513    buffer-local variable 'long_line_optimizations_p' (in 'struct
  3514    buffer') is set, and Emacs does not try to detect whether the
  3515    buffer does or does not contain long lines anymore.
  3516 
  3517    What a long line is depends on the variable 'long-line-threshold',
  3518    whose default value is 50000 (characters).
  3519 
  3520    (2) When a buffer with long lines is (re)displayed, the amount of
  3521    data that the display routines consider is, in a few well-chosen
  3522    places, limited with a temporary restriction, whose bounds are
  3523    calculated with the functions below.
  3524 
  3525    (2.1) 'get_small_narrowing_begv' is used to create a restriction
  3526    which starts a few hundred characters before point.  The exact
  3527    number of characters depends on the width of the window in which
  3528    the buffer is displayed.
  3529 
  3530    There is no corresponding 'get_small_narrowing_zv' function,
  3531    because it is not necessary to set the end limit of that
  3532    restriction.
  3533 
  3534    This restriction is used in four places, namely:
  3535    'back_to_previous_line_start' and 'move_it_vertically_backward'
  3536    (with the 'SET_WITH_NARROWED_BEGV' macro), and in
  3537    'composition_compute_stop_pos' and 'find_automatic_composition' (in
  3538    a conditional statement depending on 'long_line_optimizations_p').
  3539 
  3540    (2.2) 'get_medium_narrowing_begv' is used to create a restriction
  3541    which starts a few thousand characters before point.  The exact
  3542    number of characters depends on the size (width and height) of the
  3543    window in which the buffer is displayed.  For performance reasons,
  3544    the return value of that function is cached in 'struct it', in the
  3545    'medium_narrowing_begv' field.
  3546 
  3547    The corresponding function 'get_medium_narrowing_zv' (and
  3548    'medium_narrowing_zv' field in 'struct it') is not used to set the
  3549    end limit of the restriction, which is again unnecessary, but to
  3550    determine, in 'reseat', whether the iterator has moved far enough
  3551    from its original position, and whether the start position of the
  3552    restriction must be computed anew.
  3553 
  3554    This restriction is used in a single place:
  3555    'get_visually_first_element', with the 'SET_WITH_NARROWED_BEGV'
  3556    macro.
  3557 
  3558    (2.3) 'get_large_narrowing_begv' and 'get_large_narrowing_zv' are
  3559    used to create a restriction which starts a few hundred thousand
  3560    characters before point and ends a few hundred thousand characters
  3561    after point.  The size of that restriction depends on the variable
  3562    'long-line-optimizations-region-size', whose default value is
  3563    500000 (characters); it can be adjusted by a few hundred characters
  3564    depending on 'long-line-optimizations-bol-search-limit', whose
  3565    default value is 128 (characters).
  3566 
  3567    For performance reasons again, the return values of these functions
  3568    are stored in the 'large_narrowing_begv' and 'large_narrowing_zv'
  3569    fields in 'struct it'.
  3570 
  3571    The restriction defined by these values is used around three
  3572    low-level hooks: around 'fontification-functions', in
  3573    'handle_fontified_prop', and around 'pre-command-hook' and
  3574    'post-command-hook', in 'safe_run_hooks_maybe_narrowed', which is
  3575    called in 'command_loop_1'.  These restrictions are set around
  3576    these hooks with 'labeled_narrow_to_region'; the restrictions are
  3577    labeled, and cannot be removed with a call to 'widen', but can be
  3578    removed with 'without-restriction' with a :label argument.
  3579 */
  3580 
  3581 static int
  3582 get_narrowed_width (struct window *w)
  3583 {
  3584   /* In a character-only terminal, only one font size is used, so we
  3585      can use a smaller factor.  */
  3586   int fact = FRAME_WINDOW_P (XFRAME (w->frame)) ? 3 : 2;
  3587   /* If the window has no fringes (in a character-only terminal or in
  3588      a GUI frame without fringes), subtract 1 from the width for the
  3589      '\' line wrapping character.  */
  3590   int width = window_body_width (w, WINDOW_BODY_IN_CANONICAL_CHARS)
  3591     - ((WINDOW_RIGHT_FRINGE_WIDTH (w) == 0
  3592         || WINDOW_LEFT_FRINGE_WIDTH (w) == 0) ? 1 : 0);
  3593   return fact * max (1, width);
  3594 }
  3595 
  3596 static int
  3597 get_narrowed_len (struct window *w)
  3598 {
  3599   int height = window_body_height (w, WINDOW_BODY_IN_CANONICAL_CHARS);
  3600   return get_narrowed_width (w) * max (1, height);
  3601 }
  3602 
  3603 static ptrdiff_t
  3604 get_medium_narrowing_begv (struct window *w, ptrdiff_t pos)
  3605 {
  3606   int len = get_narrowed_len (w);
  3607   return max ((pos / len - 1) * len, BEGV);
  3608 }
  3609 
  3610 static ptrdiff_t
  3611 get_medium_narrowing_zv (struct window *w, ptrdiff_t pos)
  3612 {
  3613   int len = get_narrowed_len (w);
  3614   return min ((pos / len + 1) * len, ZV);
  3615 }
  3616 
  3617 /* Find the position of the last BOL before POS, unless it is too far
  3618    away.  The buffer portion in which the search occurs is gradually
  3619    enlarged: [POS-500..POS], [POS-5500..POS-500],
  3620    [POS-55500..POS-5500], and finally [POS-555500..POS-55500].  Return
  3621    BEGV-1 if no BOL was found in [POS-555500..POS].  */
  3622 static ptrdiff_t
  3623 get_nearby_bol_pos (ptrdiff_t pos)
  3624 {
  3625   ptrdiff_t start, pos_bytepos, cur, next, found, bol = BEGV - 1, init_pos = pos;
  3626   int dist;
  3627   for (dist = 500; dist <= 500000; dist *= 10)
  3628     {
  3629       pos_bytepos = pos == BEGV ? BEGV_BYTE : CHAR_TO_BYTE (pos);
  3630       start = pos - dist < BEGV ? BEGV : pos - dist;
  3631       for (cur = start; cur < pos; cur = next)
  3632         {
  3633           next = find_newline1 (cur, CHAR_TO_BYTE (cur),
  3634                                 pos, pos_bytepos,
  3635                                 1, &found, NULL, false);
  3636           if (found)
  3637             bol = next;
  3638           else
  3639             break;
  3640         }
  3641       if (bol >= BEGV || start == BEGV)
  3642         break;
  3643       else
  3644         pos = pos - dist < BEGV ? BEGV : pos - dist;
  3645     }
  3646   eassert (bol <= init_pos);
  3647   return bol;
  3648 }
  3649 
  3650 ptrdiff_t
  3651 get_small_narrowing_begv (struct window *w, ptrdiff_t pos)
  3652 {
  3653   int len = get_narrowed_width (w);
  3654   ptrdiff_t bol_pos = max (get_nearby_bol_pos (pos), BEGV);
  3655   return max (bol_pos + ((pos - bol_pos) / len - 1) * len, BEGV);
  3656 }
  3657 
  3658 ptrdiff_t
  3659 get_large_narrowing_begv (ptrdiff_t pos)
  3660 {
  3661   if (long_line_optimizations_region_size <= 0)
  3662     return BEGV;
  3663   int len = long_line_optimizations_region_size / 2;
  3664   int begv = max (pos - len, BEGV);
  3665   int limit = long_line_optimizations_bol_search_limit;
  3666   while (limit > 0)
  3667     {
  3668       if (begv == BEGV || FETCH_BYTE (CHAR_TO_BYTE (begv) - 1) == '\n')
  3669         return begv;
  3670       begv--;
  3671       limit--;
  3672     }
  3673   return begv;
  3674 }
  3675 
  3676 ptrdiff_t
  3677 get_large_narrowing_zv (ptrdiff_t pos)
  3678 {
  3679   if (long_line_optimizations_region_size <= 0)
  3680     return ZV;
  3681   int len = long_line_optimizations_region_size / 2;
  3682   return min (pos + len, ZV);
  3683 }
  3684 
  3685 static void
  3686 unwind_narrowed_begv (Lisp_Object point_min)
  3687 {
  3688   SET_BUF_BEGV (current_buffer, XFIXNUM (point_min));
  3689 }
  3690 
  3691 /* Set DST to EXPR.  When IT indicates that BEGV should temporarily be
  3692    updated to optimize display, evaluate EXPR with BEGV set to BV.  */
  3693 
  3694 #define SET_WITH_NARROWED_BEGV(IT,DST,EXPR,BV)                          \
  3695   do {                                                                  \
  3696     if (IT->medium_narrowing_begv)                                      \
  3697       {                                                                 \
  3698         specpdl_ref count = SPECPDL_INDEX ();                           \
  3699         record_unwind_protect (unwind_narrowed_begv, Fpoint_min ());    \
  3700         SET_BUF_BEGV (current_buffer, BV);                              \
  3701         DST = EXPR;                                                     \
  3702         unbind_to (count, Qnil);                                        \
  3703       }                                                                 \
  3704     else                                                                \
  3705       DST = EXPR;                                                       \
  3706   } while (0)
  3707 
  3708 /* Initialize IT for the display of window W with window start POS.  */
  3709 
  3710 void
  3711 start_display (struct it *it, struct window *w, struct text_pos pos)
  3712 {
  3713   struct glyph_row *row;
  3714   int first_vpos = window_wants_tab_line (w) + window_wants_header_line (w);
  3715 
  3716   row = w->desired_matrix->rows + first_vpos;
  3717   init_iterator (it, w, CHARPOS (pos), BYTEPOS (pos), row, DEFAULT_FACE_ID);
  3718   it->first_vpos = first_vpos;
  3719 
  3720   /* Don't reseat to previous visible line start if current start
  3721      position is in a string or image.  */
  3722   if (it->method == GET_FROM_BUFFER && it->line_wrap != TRUNCATE)
  3723     {
  3724       int first_y = it->current_y;
  3725 
  3726       /* If window start is not at a line start, skip forward to POS to
  3727          get the correct continuation lines width.  */
  3728       bool start_at_line_beg_p = (CHARPOS (pos) == BEGV
  3729                                   || FETCH_BYTE (BYTEPOS (pos) - 1) == '\n');
  3730       if (!start_at_line_beg_p)
  3731         {
  3732           int new_x;
  3733 
  3734           reseat_at_previous_visible_line_start (it);
  3735           move_it_to (it, CHARPOS (pos), -1, -1, -1, MOVE_TO_POS);
  3736 
  3737           new_x = it->current_x + it->pixel_width;
  3738 
  3739           /* If lines are continued, this line may end in the middle
  3740              of a multi-glyph character (e.g. a control character
  3741              displayed as \003, or in the middle of an overlay
  3742              string).  In this case move_it_to above will not have
  3743              taken us to the start of the continuation line but to the
  3744              end of the continued line.  */
  3745           if (it->current_x > 0
  3746               && it->line_wrap != TRUNCATE /* Lines are continued.  */
  3747               && (/* And glyph doesn't fit on the line.  */
  3748                   new_x > it->last_visible_x
  3749                   /* Or it fits exactly and we're on a window
  3750                      system frame.  */
  3751                   || (new_x == it->last_visible_x
  3752                       && FRAME_WINDOW_P (it->f)
  3753                       && ((it->bidi_p && it->bidi_it.paragraph_dir == R2L)
  3754                           ? WINDOW_LEFT_FRINGE_WIDTH (it->w)
  3755                           : WINDOW_RIGHT_FRINGE_WIDTH (it->w)))))
  3756             {
  3757               if ((it->current.dpvec_index >= 0
  3758                    || it->current.overlay_string_index >= 0)
  3759                   /* If we are on a newline from a display vector or
  3760                      overlay string, then we are already at the end of
  3761                      a screen line; no need to go to the next line in
  3762                      that case, as this line is not really continued.
  3763                      (If we do go to the next line, C-e will not DTRT.)  */
  3764                   && it->c != '\n')
  3765                 {
  3766                   set_iterator_to_next (it, true);
  3767                   move_it_in_display_line_to (it, -1, -1, 0);
  3768                 }
  3769 
  3770               it->continuation_lines_width += it->current_x;
  3771             }
  3772           /* If the character at POS is displayed via a display
  3773              vector, move_it_to above stops at the final glyph of
  3774              IT->dpvec.  To make the caller redisplay that character
  3775              again (a.k.a. start at POS), we need to reset the
  3776              dpvec_index to the beginning of IT->dpvec.  */
  3777           else if (it->current.dpvec_index >= 0)
  3778             it->current.dpvec_index = 0;
  3779 
  3780           /* We're starting a new display line, not affected by the
  3781              height of the continued line, so clear the appropriate
  3782              fields in the iterator structure.  */
  3783           it->max_ascent = it->max_descent = 0;
  3784           it->max_phys_ascent = it->max_phys_descent = 0;
  3785 
  3786           it->current_y = first_y;
  3787           it->vpos = 0;
  3788           it->current_x = it->hpos = 0;
  3789         }
  3790     }
  3791 }
  3792 
  3793 
  3794 /* Return true if POS is a position in ellipses displayed for invisible
  3795    text.  W is the window we display, for text property lookup.  */
  3796 
  3797 static bool
  3798 in_ellipses_for_invisible_text_p (struct display_pos *pos, struct window *w)
  3799 {
  3800   Lisp_Object prop, window;
  3801   bool ellipses_p = false;
  3802   ptrdiff_t charpos = CHARPOS (pos->pos);
  3803 
  3804   /* If POS specifies a position in a display vector, this might
  3805      be for an ellipsis displayed for invisible text.  We won't
  3806      get the iterator set up for delivering that ellipsis unless
  3807      we make sure that it gets aware of the invisible text.  */
  3808   if (pos->dpvec_index >= 0
  3809       && pos->overlay_string_index < 0
  3810       && CHARPOS (pos->string_pos) < 0
  3811       && charpos > BEGV
  3812       && (XSETWINDOW (window, w),
  3813           prop = Fget_char_property (make_fixnum (charpos),
  3814                                      Qinvisible, window),
  3815           TEXT_PROP_MEANS_INVISIBLE (prop) == 0))
  3816     {
  3817       prop = Fget_char_property (make_fixnum (charpos - 1), Qinvisible,
  3818                                  window);
  3819       ellipses_p = 2 == TEXT_PROP_MEANS_INVISIBLE (prop);
  3820     }
  3821 
  3822   return ellipses_p;
  3823 }
  3824 
  3825 
  3826 /* Initialize IT for stepping through current_buffer in window W,
  3827    starting at position POS that includes overlay string and display
  3828    vector/ control character translation position information.  Value
  3829    is false if there are overlay strings with newlines at POS.  */
  3830 
  3831 static bool
  3832 init_from_display_pos (struct it *it, struct window *w, struct display_pos *pos)
  3833 {
  3834   ptrdiff_t charpos = CHARPOS (pos->pos), bytepos = BYTEPOS (pos->pos);
  3835   int i;
  3836   bool overlay_strings_with_newlines = false;
  3837 
  3838   /* If POS specifies a position in a display vector, this might
  3839      be for an ellipsis displayed for invisible text.  We won't
  3840      get the iterator set up for delivering that ellipsis unless
  3841      we make sure that it gets aware of the invisible text.  */
  3842   if (in_ellipses_for_invisible_text_p (pos, w))
  3843     {
  3844       --charpos;
  3845       bytepos = 0;
  3846     }
  3847 
  3848   /* Keep in mind: the call to reseat in init_iterator skips invisible
  3849      text, so we might end up at a position different from POS.  This
  3850      is only a problem when POS is a row start after a newline and an
  3851      overlay starts there with an after-string, and the overlay has an
  3852      invisible property.  Since we don't skip invisible text in
  3853      display_line and elsewhere immediately after consuming the
  3854      newline before the row start, such a POS will not be in a string,
  3855      but the call to init_iterator below will move us to the
  3856      after-string.  */
  3857   init_iterator (it, w, charpos, bytepos, NULL, DEFAULT_FACE_ID);
  3858 
  3859   /* This only scans the current chunk -- it should scan all chunks.
  3860      However, OVERLAY_STRING_CHUNK_SIZE has been increased from 3 in 21.1
  3861      to 16 in 22.1 to make this a lesser problem.  */
  3862   for (i = 0; i < it->n_overlay_strings && i < OVERLAY_STRING_CHUNK_SIZE; ++i)
  3863     {
  3864       const char *s = SSDATA (it->overlay_strings[i]);
  3865       const char *e = s + SBYTES (it->overlay_strings[i]);
  3866 
  3867       while (s < e && *s != '\n')
  3868         ++s;
  3869 
  3870       if (s < e)
  3871         {
  3872           overlay_strings_with_newlines = true;
  3873           break;
  3874         }
  3875     }
  3876 
  3877   /* If position is within an overlay string, set up IT to the right
  3878      overlay string.  */
  3879   if (pos->overlay_string_index >= 0)
  3880     {
  3881       int relative_index;
  3882 
  3883       /* If the first overlay string happens to have a `display'
  3884          property for an image, the iterator will be set up for that
  3885          image, and we have to undo that setup first before we can
  3886          correct the overlay string index.  */
  3887       if (it->method == GET_FROM_IMAGE)
  3888         pop_it (it);
  3889 
  3890       /* We already have the first chunk of overlay strings in
  3891          IT->overlay_strings.  Load more until the one for
  3892          pos->overlay_string_index is in IT->overlay_strings.  */
  3893       if (pos->overlay_string_index >= OVERLAY_STRING_CHUNK_SIZE)
  3894         {
  3895           ptrdiff_t n = pos->overlay_string_index / OVERLAY_STRING_CHUNK_SIZE;
  3896           it->current.overlay_string_index = 0;
  3897           while (n--)
  3898             {
  3899               load_overlay_strings (it, 0);
  3900               it->current.overlay_string_index += OVERLAY_STRING_CHUNK_SIZE;
  3901             }
  3902         }
  3903 
  3904       it->current.overlay_string_index = pos->overlay_string_index;
  3905       relative_index = (it->current.overlay_string_index
  3906                         % OVERLAY_STRING_CHUNK_SIZE);
  3907       it->string = it->overlay_strings[relative_index];
  3908       eassert (STRINGP (it->string));
  3909       it->current.string_pos = pos->string_pos;
  3910       it->method = GET_FROM_STRING;
  3911       it->end_charpos = SCHARS (it->string);
  3912       /* Set up the bidi iterator for this overlay string.  */
  3913       if (it->bidi_p)
  3914         {
  3915           it->bidi_it.string.lstring = it->string;
  3916           it->bidi_it.string.s = NULL;
  3917           it->bidi_it.string.schars = SCHARS (it->string);
  3918           it->bidi_it.string.bufpos = it->overlay_strings_charpos;
  3919           it->bidi_it.string.from_disp_str = it->string_from_display_prop_p;
  3920           it->bidi_it.string.unibyte = !it->multibyte_p;
  3921           it->bidi_it.w = it->w;
  3922           bidi_init_it (IT_STRING_CHARPOS (*it), IT_STRING_BYTEPOS (*it),
  3923                         FRAME_WINDOW_P (it->f), &it->bidi_it);
  3924 
  3925           /* Synchronize the state of the bidi iterator with
  3926              pos->string_pos.  For any string position other than
  3927              zero, this will be done automagically when we resume
  3928              iteration over the string and get_visually_first_element
  3929              is called.  But if string_pos is zero, and the string is
  3930              to be reordered for display, we need to resync manually,
  3931              since it could be that the iteration state recorded in
  3932              pos ended at string_pos of 0 moving backwards in string.  */
  3933           if (CHARPOS (pos->string_pos) == 0)
  3934             {
  3935               get_visually_first_element (it);
  3936               if (IT_STRING_CHARPOS (*it) != 0)
  3937                 do {
  3938                   /* Paranoia.  */
  3939                   eassert (it->bidi_it.charpos < it->bidi_it.string.schars);
  3940                   bidi_move_to_visually_next (&it->bidi_it);
  3941                 } while (it->bidi_it.charpos != 0);
  3942             }
  3943           eassert (IT_STRING_CHARPOS (*it) == it->bidi_it.charpos
  3944                    && IT_STRING_BYTEPOS (*it) == it->bidi_it.bytepos);
  3945         }
  3946     }
  3947 
  3948   if (CHARPOS (pos->string_pos) >= 0)
  3949     {
  3950       /* Recorded position is not in an overlay string, but in another
  3951          string.  This can only be a string from a `display' property.
  3952          IT should already be filled with that string.  */
  3953       it->current.string_pos = pos->string_pos;
  3954       eassert (STRINGP (it->string));
  3955       if (it->bidi_p)
  3956         bidi_init_it (IT_STRING_CHARPOS (*it), IT_STRING_BYTEPOS (*it),
  3957                       FRAME_WINDOW_P (it->f), &it->bidi_it);
  3958     }
  3959 
  3960   /* Restore position in display vector translations, control
  3961      character translations or ellipses.  */
  3962   if (pos->dpvec_index >= 0)
  3963     {
  3964       if (it->dpvec == NULL)
  3965         get_next_display_element (it);
  3966       eassert (it->dpvec && it->current.dpvec_index == 0);
  3967       it->current.dpvec_index = pos->dpvec_index;
  3968     }
  3969 
  3970   CHECK_IT (it);
  3971   return !overlay_strings_with_newlines;
  3972 }
  3973 
  3974 
  3975 /* Initialize IT for stepping through current_buffer in window W
  3976    starting at ROW->start.  */
  3977 
  3978 static void
  3979 init_to_row_start (struct it *it, struct window *w, struct glyph_row *row)
  3980 {
  3981   init_from_display_pos (it, w, &row->start);
  3982   it->start = row->start;
  3983   it->continuation_lines_width = row->continuation_lines_width;
  3984   CHECK_IT (it);
  3985 }
  3986 
  3987 
  3988 /* Initialize IT for stepping through current_buffer in window W
  3989    starting in the line following ROW, i.e. starting at ROW->end.
  3990    Value is false if there are overlay strings with newlines at ROW's
  3991    end position, or if the following row begins with bidi-reordered
  3992    characters that could be composed.  */
  3993 
  3994 static bool
  3995 init_to_row_end (struct it *it, struct window *w, struct glyph_row *row)
  3996 {
  3997   bool success = false;
  3998 
  3999   if (init_from_display_pos (it, w, &row->end))
  4000     {
  4001       if (row->continued_p)
  4002         it->continuation_lines_width
  4003           = row->continuation_lines_width + row->pixel_width;
  4004       CHECK_IT (it);
  4005       /* Initializing IT in the presence of compositions in reordered
  4006          rows is tricky: row->end above will generally cause us to
  4007          start at position that is not the first one in the logical
  4008          order, and we might therefore miss the composition earlier in
  4009          the buffer that affects how glypsh are laid out in this row.
  4010          So we punt instead.  Note: the test below works because
  4011          get_next_display_element calls get_visually_first_element,
  4012          which calls composition_compute_stop_pos, which populates
  4013          it->cmp_it.  */
  4014       if (get_next_display_element (it)
  4015           && (it->bidi_it.scan_dir == -1 && it->cmp_it.id >= 0))
  4016         success = false;
  4017       else
  4018         success = true;
  4019     }
  4020 
  4021   return success;
  4022 }
  4023 
  4024 
  4025 
  4026 
  4027 /***********************************************************************
  4028                            Text properties
  4029  ***********************************************************************/
  4030 
  4031 /* Called when IT reaches IT->stop_charpos.  Handle text property and
  4032    overlay changes.  Set IT->stop_charpos to the next position where
  4033    to stop.  */
  4034 
  4035 static void
  4036 handle_stop (struct it *it)
  4037 {
  4038   enum prop_handled handled;
  4039   bool handle_overlay_change_p;
  4040   struct props *p;
  4041 
  4042   it->dpvec = NULL;
  4043   it->current.dpvec_index = -1;
  4044   handle_overlay_change_p = !it->ignore_overlay_strings_at_pos_p;
  4045   it->ellipsis_p = false;
  4046 
  4047   /* Use face of preceding text for ellipsis (if invisible) */
  4048   if (it->selective_display_ellipsis_p)
  4049     it->saved_face_id = it->face_id;
  4050 
  4051   /* Here's the description of the semantics of, and the logic behind,
  4052      the various HANDLED_* statuses:
  4053 
  4054      HANDLED_NORMALLY means the handler did its job, and the loop
  4055      should proceed to calling the next handler in order.
  4056 
  4057      HANDLED_RECOMPUTE_PROPS means the handler caused a significant
  4058      change in the properties and overlays at current position, so the
  4059      loop should be restarted, to re-invoke the handlers that were
  4060      already called.  This happens when fontification-functions were
  4061      called by handle_fontified_prop, and actually fontified
  4062      something.  Another case where HANDLED_RECOMPUTE_PROPS is
  4063      returned is when we discover overlay strings that need to be
  4064      displayed right away.  The loop below will continue for as long
  4065      as the status is HANDLED_RECOMPUTE_PROPS.
  4066 
  4067      HANDLED_RETURN means return immediately to the caller, to
  4068      continue iteration without calling any further handlers.  This is
  4069      used when we need to act on some property right away, for example
  4070      when we need to display the ellipsis or a replacing display
  4071      property, such as display string or image.
  4072 
  4073      HANDLED_OVERLAY_STRING_CONSUMED means an overlay string was just
  4074      consumed, and the handler switched to the next overlay string.
  4075      This signals the loop below to refrain from looking for more
  4076      overlays before all the overlay strings of the current overlay
  4077      are processed.
  4078 
  4079      Some of the handlers called by the loop push the iterator state
  4080      onto the stack (see 'push_it'), and arrange for the iteration to
  4081      continue with another object, such as an image, a display string,
  4082      or an overlay string.  In most such cases, it->stop_charpos is
  4083      set to the first character of the string, so that when the
  4084      iteration resumes, this function will immediately be called
  4085      again, to examine the properties at the beginning of the string.
  4086 
  4087      When a display or overlay string is exhausted, the iterator state
  4088      is popped (see 'pop_it'), and iteration continues with the
  4089      previous object.  Again, in many such cases this function is
  4090      called again to find the next position where properties might
  4091      change.  */
  4092 
  4093   do
  4094     {
  4095       handled = HANDLED_NORMALLY;
  4096 
  4097       /* Call text property handlers.  */
  4098       for (p = it_props; p->handler; ++p)
  4099         {
  4100           handled = p->handler (it);
  4101 
  4102           if (handled == HANDLED_RECOMPUTE_PROPS)
  4103             break;
  4104           else if (handled == HANDLED_RETURN)
  4105             {
  4106               /* We still want to show before and after strings from
  4107                  overlays even if the actual buffer text is replaced.  */
  4108               if (!handle_overlay_change_p
  4109                   || it->sp > 1
  4110                   /* Don't call get_overlay_strings_1 if we already
  4111                      have overlay strings loaded, because doing so
  4112                      will load them again and push the iterator state
  4113                      onto the stack one more time, which is not
  4114                      expected by the rest of the code that processes
  4115                      overlay strings.  */
  4116                   || (it->current.overlay_string_index < 0
  4117                       && !get_overlay_strings_1 (it, 0, false)))
  4118                 {
  4119                   if (it->ellipsis_p)
  4120                     setup_for_ellipsis (it, 0);
  4121                   /* When handling a display spec, we might load an
  4122                      empty string.  In that case, discard it here.  We
  4123                      used to discard it in handle_single_display_spec,
  4124                      but that causes get_overlay_strings_1, above, to
  4125                      ignore overlay strings that we must check.  */
  4126                   if (STRINGP (it->string) && !SCHARS (it->string))
  4127                     pop_it (it);
  4128                   return;
  4129                 }
  4130               else if (STRINGP (it->string) && !SCHARS (it->string))
  4131                 pop_it (it);
  4132               else
  4133                 {
  4134                   it->string_from_display_prop_p = false;
  4135                   it->from_disp_prop_p = false;
  4136                   handle_overlay_change_p = false;
  4137                 }
  4138               handled = HANDLED_RECOMPUTE_PROPS;
  4139               break;
  4140             }
  4141           else if (handled == HANDLED_OVERLAY_STRING_CONSUMED)
  4142             handle_overlay_change_p = false;
  4143         }
  4144 
  4145       if (handled != HANDLED_RECOMPUTE_PROPS)
  4146         {
  4147           /* Don't check for overlay strings below when set to deliver
  4148              characters from a display vector.  */
  4149           if (it->method == GET_FROM_DISPLAY_VECTOR)
  4150             handle_overlay_change_p = false;
  4151 
  4152           /* Handle overlay changes.
  4153              This sets HANDLED to HANDLED_RECOMPUTE_PROPS
  4154              if it finds overlays.  */
  4155           if (handle_overlay_change_p)
  4156             handled = handle_overlay_change (it);
  4157         }
  4158 
  4159       if (it->ellipsis_p)
  4160         {
  4161           setup_for_ellipsis (it, 0);
  4162           break;
  4163         }
  4164     }
  4165   while (handled == HANDLED_RECOMPUTE_PROPS);
  4166 
  4167   /* Determine where to stop next.  */
  4168   if (handled == HANDLED_NORMALLY)
  4169     compute_stop_pos (it);
  4170 }
  4171 
  4172 
  4173 /* Compute IT->stop_charpos from text property and overlay change
  4174    information for IT's current position.  */
  4175 
  4176 static void
  4177 compute_stop_pos (struct it *it)
  4178 {
  4179   register INTERVAL iv, next_iv;
  4180   Lisp_Object object, limit, position;
  4181   ptrdiff_t charpos, bytepos, cmp_limit_pos = -1;
  4182 
  4183   if (STRINGP (it->string))
  4184     {
  4185       /* Strings are usually short, so don't limit the search for
  4186          properties.  */
  4187       it->stop_charpos = it->end_charpos;
  4188       object = it->string;
  4189       limit = Qnil;
  4190       charpos = IT_STRING_CHARPOS (*it);
  4191       bytepos = IT_STRING_BYTEPOS (*it);
  4192     }
  4193   else
  4194     {
  4195       ptrdiff_t pos;
  4196 
  4197       /* If end_charpos is out of range for some reason, such as a
  4198          misbehaving display function, rationalize it (Bug#5984).  */
  4199       if (it->end_charpos > ZV)
  4200         it->end_charpos = ZV;
  4201       it->stop_charpos = it->end_charpos;
  4202 
  4203       /* If next overlay change is in front of the current stop pos
  4204          (which is IT->end_charpos), stop there.  Note: value of
  4205          next_overlay_change is point-max if no overlay change
  4206          follows.  */
  4207       charpos = IT_CHARPOS (*it);
  4208       bytepos = IT_BYTEPOS (*it);
  4209       pos = next_overlay_change (charpos);
  4210       if (pos < it->stop_charpos)
  4211         it->stop_charpos = pos;
  4212       /* If we are breaking compositions at point, stop at point.  */
  4213       if (!NILP (BVAR (current_buffer, enable_multibyte_characters))
  4214           && !NILP (Vauto_composition_mode)
  4215           && composition_break_at_point
  4216           && charpos < PT && PT < it->stop_charpos)
  4217         it->stop_charpos = PT;
  4218 
  4219       /* Set up variables for computing the stop position from text
  4220          property changes.  */
  4221       XSETBUFFER (object, current_buffer);
  4222       pos = charpos + TEXT_PROP_DISTANCE_LIMIT;
  4223       /* Make sure the above arbitrary limit position is not in the
  4224          middle of composable text, so we don't break compositions by
  4225          submitting the composable text to the shaper in separate
  4226          chunks.  We play safe here by assuming that only SPC, TAB,
  4227          FF, and NL cannot be in some composition; in particular, most
  4228          ASCII punctuation characters could be composed into ligatures.  */
  4229       if (!composition_break_at_point
  4230           && !NILP (BVAR (current_buffer, enable_multibyte_characters))
  4231           && !NILP (Vauto_composition_mode))
  4232         {
  4233           ptrdiff_t endpos = charpos + 10 * TEXT_PROP_DISTANCE_LIMIT;
  4234           bool found = false;
  4235 
  4236           if (pos > ZV)
  4237             pos = ZV;
  4238           if (endpos > ZV)
  4239             endpos = ZV;
  4240           ptrdiff_t bpos = CHAR_TO_BYTE (pos);
  4241           while (pos < endpos)
  4242             {
  4243               int ch = fetch_char_advance_no_check (&pos, &bpos);
  4244               if (ch == ' ' || ch == '\t' || ch == '\n' || ch == '\f')
  4245                 {
  4246                   found = true;
  4247                   break;
  4248                 }
  4249             }
  4250           if (found)
  4251             {
  4252               pos--;
  4253               cmp_limit_pos = pos;
  4254             }
  4255           else if (it->stop_charpos < endpos)
  4256             pos = it->stop_charpos;
  4257           else
  4258             {
  4259               /* Give up and use the original arbitrary limit.  */
  4260               pos = charpos + TEXT_PROP_DISTANCE_LIMIT;
  4261             }
  4262         }
  4263       limit = make_fixnum (pos);
  4264     }
  4265 
  4266   /* Get the interval containing IT's position.  Value is a null
  4267      interval if there isn't such an interval.  */
  4268   position = make_fixnum (charpos);
  4269   iv = validate_interval_range (object, &position, &position, false);
  4270   if (iv)
  4271     {
  4272       Lisp_Object values_here[LAST_PROP_IDX];
  4273       struct props *p;
  4274 
  4275       /* Get properties here.  */
  4276       for (p = it_props; p->handler; ++p)
  4277         values_here[p->idx] = textget (iv->plist,
  4278                                        builtin_lisp_symbol (p->name));
  4279 
  4280       /* Look for an interval following iv that has different
  4281          properties.  */
  4282       for (next_iv = next_interval (iv);
  4283            (next_iv
  4284             && (NILP (limit)
  4285                 || XFIXNAT (limit) > next_iv->position));
  4286            next_iv = next_interval (next_iv))
  4287         {
  4288           for (p = it_props; p->handler; ++p)
  4289             {
  4290               Lisp_Object new_value = textget (next_iv->plist,
  4291                                                builtin_lisp_symbol (p->name));
  4292               if (!EQ (values_here[p->idx], new_value))
  4293                 break;
  4294             }
  4295 
  4296           if (p->handler)
  4297             break;
  4298         }
  4299 
  4300       if (next_iv)
  4301         {
  4302           if (FIXNUMP (limit)
  4303               && next_iv->position >= XFIXNAT (limit))
  4304             /* No text property change up to limit.  */
  4305             it->stop_charpos = min (XFIXNAT (limit), it->stop_charpos);
  4306           else
  4307             /* Text properties change in next_iv.  */
  4308             it->stop_charpos = min (it->stop_charpos, next_iv->position);
  4309         }
  4310     }
  4311 
  4312   if (it->cmp_it.id < 0
  4313       && (STRINGP (it->string)
  4314           || ((!it->bidi_p || it->bidi_it.scan_dir >= 0)
  4315               && it->cmp_it.stop_pos <= IT_CHARPOS (*it))))
  4316     {
  4317       ptrdiff_t stoppos = it->end_charpos;
  4318 
  4319       /* If we found, above, a buffer position that cannot be part of
  4320          an automatic composition, limit the search of composable
  4321          characters to that position.  */
  4322       if (it->bidi_p && it->bidi_it.scan_dir < 0)
  4323         stoppos = -1;
  4324       else if (cmp_limit_pos > 0)
  4325         stoppos = cmp_limit_pos;
  4326       /* Force composition_compute_stop_pos avoid the costly search
  4327          for static compositions, since those were already found by
  4328          looking at text properties, above.  */
  4329       composition_compute_stop_pos (&it->cmp_it, charpos, bytepos,
  4330                                     stoppos, it->string, false);
  4331     }
  4332 
  4333   eassert (STRINGP (it->string)
  4334            || (it->stop_charpos >= BEGV
  4335                && it->stop_charpos >= IT_CHARPOS (*it)));
  4336 }
  4337 
  4338 /* How many characters forward to search for a display property or
  4339    display string.  Searching too far forward makes the bidi display
  4340    sluggish, especially in small windows.  */
  4341 #define MAX_DISP_SCAN 250
  4342 
  4343 /* Return the character position of a display string at or after
  4344    position specified by POSITION.  If no display string exists at or
  4345    after POSITION, return ZV.  A display string is either an overlay
  4346    with `display' property whose value is a string, or a `display'
  4347    text property whose value is a string.  STRING is data about the
  4348    string to iterate; if STRING->lstring is nil, we are iterating a
  4349    buffer.  FRAME_WINDOW_P is true when we are displaying a window
  4350    on a GUI frame.  DISP_PROP is set to zero if we searched
  4351    MAX_DISP_SCAN characters forward without finding any display
  4352    strings, non-zero otherwise.  It is set to 2 if the display string
  4353    uses any kind of `(space ...)' spec that will produce a stretch of
  4354    white space in the text area.  */
  4355 ptrdiff_t
  4356 compute_display_string_pos (struct text_pos *position,
  4357                             struct bidi_string_data *string,
  4358                             struct window *w,
  4359                             bool frame_window_p, int *disp_prop)
  4360 {
  4361   /* OBJECT = nil means current buffer.  */
  4362   Lisp_Object object, object1;
  4363   Lisp_Object pos, spec, limpos;
  4364   bool string_p = string && (STRINGP (string->lstring) || string->s);
  4365   ptrdiff_t eob = string_p ? string->schars : ZV;
  4366   ptrdiff_t begb = string_p ? 0 : BEGV;
  4367   ptrdiff_t bufpos, charpos = CHARPOS (*position);
  4368   ptrdiff_t lim =
  4369     (charpos < eob - MAX_DISP_SCAN) ? charpos + MAX_DISP_SCAN : eob;
  4370   struct text_pos tpos;
  4371   int rv = 0;
  4372 
  4373   if (string && STRINGP (string->lstring))
  4374     object1 = object = string->lstring;
  4375   else if (w && !string_p)
  4376     {
  4377       XSETWINDOW (object, w);
  4378       object1 = Qnil;
  4379     }
  4380   else
  4381     object1 = object = Qnil;
  4382 
  4383   *disp_prop = 1;
  4384 
  4385   if (charpos >= eob
  4386       /* We don't support display properties whose values are strings
  4387          that have display string properties.  */
  4388       || string->from_disp_str
  4389       /* C strings cannot have display properties.  */
  4390       || (string->s && !STRINGP (object)))
  4391     {
  4392       *disp_prop = 0;
  4393       return eob;
  4394     }
  4395 
  4396   /* If the character at CHARPOS is where the display string begins,
  4397      return CHARPOS.  */
  4398   pos = make_fixnum (charpos);
  4399   if (STRINGP (object))
  4400     bufpos = string->bufpos;
  4401   else
  4402     bufpos = charpos;
  4403   tpos = *position;
  4404   if (!NILP (spec = Fget_char_property (pos, Qdisplay, object))
  4405       && (charpos <= begb
  4406           || !EQ (Fget_char_property (make_fixnum (charpos - 1), Qdisplay,
  4407                                       object),
  4408                   spec))
  4409       && (rv = handle_display_spec (NULL, spec, object1, Qnil, &tpos, bufpos,
  4410                                     frame_window_p)))
  4411     {
  4412       if (rv == 2)
  4413         *disp_prop = 2;
  4414       return charpos;
  4415     }
  4416 
  4417   /* Look forward for the first character with a `display' property
  4418      that will replace the underlying text when displayed.  */
  4419   limpos = make_fixnum (lim);
  4420   do {
  4421     pos = Fnext_single_char_property_change (pos, Qdisplay, object1, limpos);
  4422     CHARPOS (tpos) = XFIXNAT (pos);
  4423     if (CHARPOS (tpos) >= lim)
  4424       {
  4425         *disp_prop = 0;
  4426         break;
  4427       }
  4428     if (STRINGP (object))
  4429       BYTEPOS (tpos) = string_char_to_byte (object, CHARPOS (tpos));
  4430     else
  4431       BYTEPOS (tpos) = CHAR_TO_BYTE (CHARPOS (tpos));
  4432     spec = Fget_char_property (pos, Qdisplay, object);
  4433     if (!STRINGP (object))
  4434       bufpos = CHARPOS (tpos);
  4435   } while (NILP (spec)
  4436            || !(rv = handle_display_spec (NULL, spec, object1, Qnil, &tpos,
  4437                                           bufpos, frame_window_p)));
  4438   if (rv == 2)
  4439     *disp_prop = 2;
  4440 
  4441   return CHARPOS (tpos);
  4442 }
  4443 
  4444 /* Return the character position of the end of the display string that
  4445    started at CHARPOS.  If there's no display string at CHARPOS,
  4446    return -1.  A display string is either an overlay with `display'
  4447    property whose value is a string or a `display' text property whose
  4448    value is a string.  */
  4449 ptrdiff_t
  4450 compute_display_string_end (ptrdiff_t charpos, struct bidi_string_data *string)
  4451 {
  4452   /* OBJECT = nil means current buffer.  */
  4453   Lisp_Object object =
  4454     (string && STRINGP (string->lstring)) ? string->lstring : Qnil;
  4455   Lisp_Object pos = make_fixnum (charpos);
  4456   ptrdiff_t eob =
  4457     (STRINGP (object) || (string && string->s)) ? string->schars : ZV;
  4458 
  4459   if (charpos >= eob || (string->s && !STRINGP (object)))
  4460     return eob;
  4461 
  4462   /* It could happen that the display property or overlay was removed
  4463      since we found it in compute_display_string_pos above.  One way
  4464      this can happen is if JIT font-lock was called (through
  4465      handle_fontified_prop), and jit-lock-functions remove text
  4466      properties or overlays from the portion of buffer that includes
  4467      CHARPOS.  Muse mode is known to do that, for example.  In this
  4468      case, we return -1 to the caller, to signal that no display
  4469      string is actually present at CHARPOS.  See bidi_fetch_char for
  4470      how this is handled.
  4471 
  4472      An alternative would be to never look for display properties past
  4473      it->stop_charpos.  But neither compute_display_string_pos nor
  4474      bidi_fetch_char that calls it know or care where the next
  4475      stop_charpos is.  */
  4476   if (NILP (Fget_char_property (pos, Qdisplay, object)))
  4477     return -1;
  4478 
  4479   /* Look forward for the first character where the `display' property
  4480      changes.  */
  4481   pos = Fnext_single_char_property_change (pos, Qdisplay, object, Qnil);
  4482 
  4483   return XFIXNAT (pos);
  4484 }
  4485 
  4486 
  4487 
  4488 /***********************************************************************
  4489                             Fontification
  4490  ***********************************************************************/
  4491 
  4492 /* Handle changes in the `fontified' property of the current buffer by
  4493    calling hook functions from Qfontification_functions to fontify
  4494    regions of text.  */
  4495 
  4496 static enum prop_handled
  4497 handle_fontified_prop (struct it *it)
  4498 {
  4499   Lisp_Object prop, pos;
  4500   enum prop_handled handled = HANDLED_NORMALLY;
  4501 
  4502   if (!NILP (Vmemory_full))
  4503     return handled;
  4504 
  4505   /* Get the value of the `fontified' property at IT's current buffer
  4506      position.  (The `fontified' property doesn't have a special
  4507      meaning in strings.)  If the value is nil, call functions from
  4508      Qfontification_functions.  */
  4509   if (!STRINGP (it->string)
  4510       && it->s == NULL
  4511       && !NILP (Vfontification_functions)
  4512       && !(input_was_pending && redisplay_skip_fontification_on_input)
  4513       && !NILP (Vrun_hooks)
  4514       && (pos = make_fixnum (IT_CHARPOS (*it)),
  4515           prop = Fget_char_property (pos, Qfontified, Qnil),
  4516           /* Ignore the special cased nil value always present at EOB since
  4517              no amount of fontifying will be able to change it.  */
  4518           NILP (prop) && IT_CHARPOS (*it) < Z))
  4519     {
  4520       specpdl_ref count = SPECPDL_INDEX ();
  4521       Lisp_Object val;
  4522       struct buffer *obuf = current_buffer;
  4523       ptrdiff_t begv = BEGV, zv = ZV;
  4524       bool old_clip_changed = current_buffer->clip_changed;
  4525       bool saved_inhibit_flag = it->f->inhibit_clear_image_cache;
  4526 
  4527       val = Vfontification_functions;
  4528       specbind (Qfontification_functions, Qnil);
  4529 
  4530       eassert (it->end_charpos == ZV);
  4531 
  4532       if (current_buffer->long_line_optimizations_p
  4533           && long_line_optimizations_region_size > 0)
  4534         {
  4535           ptrdiff_t begv = it->large_narrowing_begv;
  4536           ptrdiff_t zv = it->large_narrowing_zv;
  4537           ptrdiff_t charpos = IT_CHARPOS (*it);
  4538           if (charpos < begv || charpos > zv)
  4539             {
  4540               begv = get_large_narrowing_begv (charpos);
  4541               zv = get_large_narrowing_zv (charpos);
  4542             }
  4543           if (begv != BEG || zv != Z)
  4544             labeled_narrow_to_region (make_fixnum (begv), make_fixnum (zv),
  4545                                       Qlong_line_optimizations_in_fontification_functions);
  4546         }
  4547 
  4548       /* Don't allow Lisp that runs from 'fontification-functions'
  4549          clear our face and image caches behind our back.  */
  4550       it->f->inhibit_clear_image_cache = true;
  4551 
  4552       if (!CONSP (val) || EQ (XCAR (val), Qlambda))
  4553         safe_call1 (val, pos);
  4554       else
  4555         {
  4556           Lisp_Object fns, fn;
  4557 
  4558           fns = Qnil;
  4559 
  4560           for (; CONSP (val); val = XCDR (val))
  4561             {
  4562               fn = XCAR (val);
  4563 
  4564               if (EQ (fn, Qt))
  4565                 {
  4566                   /* A value of t indicates this hook has a local
  4567                      binding; it means to run the global binding too.
  4568                      In a global value, t should not occur.  If it
  4569                      does, we must ignore it to avoid an endless
  4570                      loop.  */
  4571                   for (fns = Fdefault_value (Qfontification_functions);
  4572                        CONSP (fns);
  4573                        fns = XCDR (fns))
  4574                     {
  4575                       fn = XCAR (fns);
  4576                       if (!EQ (fn, Qt))
  4577                         safe_call1 (fn, pos);
  4578                     }
  4579                 }
  4580               else
  4581                 safe_call1 (fn, pos);
  4582             }
  4583         }
  4584 
  4585       it->f->inhibit_clear_image_cache = saved_inhibit_flag;
  4586       unbind_to (count, Qnil);
  4587 
  4588       /* Fontification functions routinely call `save-restriction'.
  4589          Normally, this tags clip_changed, which can confuse redisplay
  4590          (see discussion in Bug#6671).  Since we don't perform any
  4591          special handling of fontification changes in the case where
  4592          `save-restriction' isn't called, there's no point doing so in
  4593          this case either.  So, if the buffer's restrictions are
  4594          actually left unchanged, reset clip_changed.  */
  4595       if (obuf == current_buffer)
  4596         {
  4597           if (begv == BEGV && zv == ZV)
  4598             current_buffer->clip_changed = old_clip_changed;
  4599         }
  4600       /* There isn't much we can reasonably do to protect against
  4601          misbehaving fontification, but here's a fig leaf.  */
  4602       else if (BUFFER_LIVE_P (obuf))
  4603         set_buffer_internal_1 (obuf);
  4604 
  4605       /* The fontification code may have added/removed text.
  4606          It could do even a lot worse, but let's at least protect against
  4607          the most obvious case where only the text past `pos' gets changed',
  4608          as is/was done in grep.el where some escapes sequences are turned
  4609          into face properties (bug#7876).  */
  4610       it->end_charpos = ZV;
  4611 
  4612       /* Return HANDLED_RECOMPUTE_PROPS only if function fontified
  4613          something.  This avoids an endless loop if they failed to
  4614          fontify the text for which reason ever.  */
  4615       if (!NILP (Fget_char_property (pos, Qfontified, Qnil)))
  4616         handled = HANDLED_RECOMPUTE_PROPS;
  4617     }
  4618 
  4619   return handled;
  4620 }
  4621 
  4622 
  4623 
  4624 /***********************************************************************
  4625                                 Faces
  4626  ***********************************************************************/
  4627 
  4628 static int
  4629 face_at_pos (const struct it *it, enum lface_attribute_index attr_filter)
  4630 {
  4631   ptrdiff_t next_stop;
  4632 
  4633   if (!STRINGP (it->string))
  4634     {
  4635       return face_at_buffer_position (it->w,
  4636                                       IT_CHARPOS (*it),
  4637                                       &next_stop,
  4638                                       (IT_CHARPOS (*it)
  4639                                        + TEXT_PROP_DISTANCE_LIMIT),
  4640                                       false, it->base_face_id,
  4641                                       attr_filter);
  4642     }
  4643   else
  4644     {
  4645       int base_face_id;
  4646       ptrdiff_t bufpos;
  4647       int i;
  4648       Lisp_Object from_overlay
  4649         = (it->current.overlay_string_index >= 0
  4650            ? it->string_overlays[it->current.overlay_string_index
  4651                                  % OVERLAY_STRING_CHUNK_SIZE]
  4652            : Qnil);
  4653 
  4654       /* See if we got to this string directly or indirectly from
  4655          an overlay property.  That includes the before-string or
  4656          after-string of an overlay, strings in display properties
  4657          provided by an overlay, their text properties, etc.
  4658 
  4659          FROM_OVERLAY is the overlay that brought us here, or nil if none.  */
  4660       if (! NILP (from_overlay))
  4661         for (i = it->sp - 1; i >= 0; i--)
  4662           {
  4663             if (it->stack[i].current.overlay_string_index >= 0)
  4664               from_overlay
  4665                 = it->string_overlays[it->stack[i].current.overlay_string_index
  4666                                       % OVERLAY_STRING_CHUNK_SIZE];
  4667             else if (! NILP (it->stack[i].from_overlay))
  4668               from_overlay = it->stack[i].from_overlay;
  4669 
  4670             if (!NILP (from_overlay))
  4671               break;
  4672           }
  4673 
  4674       if (! NILP (from_overlay))
  4675         {
  4676           bufpos = IT_CHARPOS (*it);
  4677           /* For a string from an overlay, the base face depends
  4678              only on text properties and ignores overlays.  */
  4679           base_face_id
  4680             = face_for_overlay_string (it->w,
  4681                                        IT_CHARPOS (*it),
  4682                                        &next_stop,
  4683                                        (IT_CHARPOS (*it)
  4684                                         + TEXT_PROP_DISTANCE_LIMIT),
  4685                                        false,
  4686                                        from_overlay, attr_filter);
  4687         }
  4688       else
  4689         {
  4690           bufpos = 0;
  4691 
  4692           /* For strings from a `display' property, use the face at
  4693              IT's current buffer position as the base face to merge
  4694              with, so that overlay strings appear in the same face as
  4695              surrounding text, unless they specify their own faces.
  4696              For strings from wrap-prefix and line-prefix properties,
  4697              use the default face, possibly remapped via
  4698              Vface_remapping_alist.  */
  4699           /* Note that the fact that we use the face at _buffer_
  4700              position means that a 'display' property on an overlay
  4701              string will not inherit the face of that overlay string,
  4702              but will instead revert to the face of buffer text
  4703              covered by the overlay.  This is visible, e.g., when the
  4704              overlay specifies a box face, but neither the buffer nor
  4705              the display string do.  This sounds like a design bug,
  4706              but Emacs always did that since v21.1, so changing that
  4707              might be a big deal.  */
  4708           base_face_id = it->string_from_prefix_prop_p
  4709             ? (!NILP (Vface_remapping_alist)
  4710                ? lookup_basic_face (it->w, it->f, DEFAULT_FACE_ID)
  4711                : DEFAULT_FACE_ID)
  4712             : underlying_face_id (it);
  4713         }
  4714 
  4715       return face_at_string_position (it->w,
  4716                                       it->string,
  4717                                       IT_STRING_CHARPOS (*it),
  4718                                       bufpos,
  4719                                       &next_stop,
  4720                                       base_face_id, false,
  4721                                       attr_filter);
  4722     } /* !STRINGP (it->string) */
  4723 }
  4724 
  4725 
  4726 /* Set up iterator IT from face properties at its current position.
  4727    Called from handle_stop.  */
  4728 static enum prop_handled
  4729 handle_face_prop (struct it *it)
  4730 {
  4731   specpdl_ref count = SPECPDL_INDEX ();
  4732   /* Don't allow the user to quit out of face-merging code, in case
  4733      this is called when redisplaying a non-selected window, with
  4734      point temporarily moved to window-point.  */
  4735   specbind (Qinhibit_quit, Qt);
  4736   const int new_face_id = face_at_pos (it, 0);
  4737   unbind_to (count, Qnil);
  4738 
  4739 
  4740   /* Is this a start of a run of characters with box face?
  4741      Caveat: this can be called for a freshly initialized
  4742      iterator; face_id is -1 in this case.  We know that the new
  4743      face will not change until limit, i.e. if the new face has a
  4744      box, all characters up to limit will have one.  But, as
  4745      usual, we don't know whether limit is really the end.  */
  4746   if (new_face_id != it->face_id)
  4747     {
  4748       struct face *new_face = FACE_FROM_ID (it->f, new_face_id);
  4749       /* If it->face_id is -1, old_face below will be NULL, see
  4750          the definition of FACE_FROM_ID_OR_NULL.  This will happen
  4751          if this is the initial call that gets the face.  */
  4752       struct face *old_face = FACE_FROM_ID_OR_NULL (it->f, it->face_id);
  4753 
  4754       /* If the value of face_id of the iterator is -1, we have to
  4755          look in front of IT's position and see whether there is a
  4756          face there that's different from new_face_id.  */
  4757       if (!STRINGP (it->string)
  4758           && !old_face
  4759           && IT_CHARPOS (*it) > BEG)
  4760         {
  4761           const int prev_face_id = face_before_it_pos (it);
  4762 
  4763           old_face = FACE_FROM_ID_OR_NULL (it->f, prev_face_id);
  4764         }
  4765 
  4766       /* If the new face has a box, but the old face does not,
  4767          this is the start of a run of characters with box face,
  4768          i.e. this character has a shadow on the left side.  */
  4769       it->face_id = new_face_id;
  4770       /* Don't reset the start_of_box_run_p flag, only set it if
  4771          needed.  */
  4772       if (!(it->start_of_box_run_p && old_face && old_face->box))
  4773         it->start_of_box_run_p = (new_face->box != FACE_NO_BOX
  4774                                   && (old_face == NULL || !old_face->box));
  4775       it->face_box_p = new_face->box != FACE_NO_BOX;
  4776     }
  4777 
  4778   return HANDLED_NORMALLY;
  4779 }
  4780 
  4781 
  4782 /* Return the ID of the face ``underlying'' IT's current position,
  4783    which is in a string.  If the iterator is associated with a
  4784    buffer, return the face at IT's current buffer position.
  4785    Otherwise, use the iterator's base_face_id.  */
  4786 
  4787 static int
  4788 underlying_face_id (const struct it *it)
  4789 {
  4790   int face_id = it->base_face_id, i;
  4791 
  4792   eassert (STRINGP (it->string));
  4793 
  4794   for (i = it->sp - 1; i >= 0; --i)
  4795     if (NILP (it->stack[i].string))
  4796       face_id = it->stack[i].face_id;
  4797 
  4798   return face_id;
  4799 }
  4800 
  4801 
  4802 /* Compute the face one character before or after the current position
  4803    of IT, in the visual order.  BEFORE_P means get the face
  4804    in front (to the left in L2R paragraphs, to the right in R2L
  4805    paragraphs) of IT's screen position.  Value is the ID of the face.  */
  4806 
  4807 static int
  4808 face_before_or_after_it_pos (struct it *it, bool before_p)
  4809 {
  4810   int face_id, limit;
  4811   ptrdiff_t next_check_charpos;
  4812   struct it it_copy;
  4813   void *it_copy_data = NULL;
  4814 
  4815   eassert (it->s == NULL);
  4816 
  4817   if (STRINGP (it->string))
  4818     {
  4819       ptrdiff_t bufpos, charpos;
  4820       int base_face_id;
  4821 
  4822       /* No face change past the end of the string (for the case we
  4823          are padding with spaces).  No face change before the string
  4824          start.  Ignore face changes before the first visible
  4825          character on this display line.  */
  4826       if (IT_STRING_CHARPOS (*it) >= SCHARS (it->string)
  4827           || (IT_STRING_CHARPOS (*it) == 0 && before_p)
  4828           || it->current_x <= it->first_visible_x)
  4829         return it->face_id;
  4830 
  4831       if (!it->bidi_p)
  4832         {
  4833           /* Set charpos to the position before or after IT's current
  4834              position, in the logical order, which in the non-bidi
  4835              case is the same as the visual order.  */
  4836           if (before_p)
  4837             charpos = IT_STRING_CHARPOS (*it) - 1;
  4838           else if (it->what == IT_COMPOSITION)
  4839             /* For composition, we must check the character after the
  4840                composition.  */
  4841             charpos = IT_STRING_CHARPOS (*it) + it->cmp_it.nchars;
  4842           else
  4843             charpos = IT_STRING_CHARPOS (*it) + 1;
  4844         }
  4845       else
  4846         {
  4847           /* With bidi iteration, the character before the current in
  4848              the visual order cannot be found by simple iteration,
  4849              because "reverse" reordering is not supported.  Instead,
  4850              we need to start from the string beginning and go all the
  4851              way to the current string position, remembering the
  4852              visually-previous position.  We need to start from the
  4853              string beginning for the character after the current as
  4854              well, since the iterator state in IT may have been
  4855              pushed, and the bidi cache is no longer coherent with the
  4856              string's text.  */
  4857           SAVE_IT (it_copy, *it, it_copy_data);
  4858           IT_STRING_CHARPOS (it_copy) = 0;
  4859           bidi_init_it (0, 0, FRAME_WINDOW_P (it_copy.f), &it_copy.bidi_it);
  4860           it_copy.bidi_it.scan_dir = 0;
  4861 
  4862           do
  4863             {
  4864               charpos = it_copy.bidi_it.charpos;
  4865               if (charpos >= SCHARS (it->string))
  4866                 break;
  4867               bidi_move_to_visually_next (&it_copy.bidi_it);
  4868             }
  4869           while (it_copy.bidi_it.charpos != IT_STRING_CHARPOS (*it));
  4870 
  4871           if (!before_p)
  4872             {
  4873               /* Set charpos to the string position of the character
  4874                  that comes after IT's current position in the visual
  4875                  order.  */
  4876               int n = (it->what == IT_COMPOSITION ? it->cmp_it.nchars : 1);
  4877               /* If this is the first string character,
  4878                  bidi_move_to_visually_next will deliver character at
  4879                  current position without moving, so we need to enlarge N.  */
  4880               if (it_copy.bidi_it.first_elt)
  4881                 n++;
  4882               while (n--)
  4883                 bidi_move_to_visually_next (&it_copy.bidi_it);
  4884 
  4885               charpos = it_copy.bidi_it.charpos;
  4886             }
  4887 
  4888           RESTORE_IT (it, it, it_copy_data);
  4889         }
  4890       eassert (0 <= charpos && charpos <= SCHARS (it->string));
  4891 
  4892       if (it->current.overlay_string_index >= 0)
  4893         bufpos = IT_CHARPOS (*it);
  4894       else
  4895         bufpos = 0;
  4896 
  4897       base_face_id = underlying_face_id (it);
  4898 
  4899       /* Get the face for ASCII, or unibyte.  */
  4900       face_id = face_at_string_position (it->w, it->string, charpos,
  4901                                          bufpos, &next_check_charpos,
  4902                                          base_face_id, false, 0);
  4903 
  4904       /* Correct the face for charsets different from ASCII.  Do it
  4905          for the multibyte case only.  The face returned above is
  4906          suitable for unibyte text if IT->string is unibyte.  */
  4907       if (STRING_MULTIBYTE (it->string))
  4908         {
  4909           struct text_pos pos1 = string_pos (charpos, it->string);
  4910           const unsigned char *p = SDATA (it->string) + BYTEPOS (pos1);
  4911           struct face *face = FACE_FROM_ID (it->f, face_id);
  4912           int len, c = check_char_and_length (p, &len);
  4913           face_id = FACE_FOR_CHAR (it->f, face, c, charpos, it->string);
  4914         }
  4915     }
  4916   else
  4917     {
  4918       struct text_pos pos;
  4919 
  4920       if ((IT_CHARPOS (*it) >= ZV && !before_p)
  4921           || (IT_CHARPOS (*it) <= BEGV && before_p))
  4922         return it->face_id;
  4923 
  4924       limit = IT_CHARPOS (*it) + TEXT_PROP_DISTANCE_LIMIT;
  4925       pos = it->current.pos;
  4926 
  4927       if (!it->bidi_p)
  4928         {
  4929           if (before_p)
  4930             DEC_TEXT_POS (pos, it->multibyte_p);
  4931           else
  4932             {
  4933               if (it->what == IT_COMPOSITION)
  4934                 {
  4935                   /* For composition, we must check the position after
  4936                      the composition.  */
  4937                   pos.charpos += it->cmp_it.nchars;
  4938                   pos.bytepos += it->len;
  4939                 }
  4940               else
  4941                 INC_TEXT_POS (pos, it->multibyte_p);
  4942             }
  4943         }
  4944       else
  4945         {
  4946           if (before_p)
  4947             {
  4948               int current_x;
  4949 
  4950               /* With bidi iteration, the character before the current
  4951                  in the visual order cannot be found by simple
  4952                  iteration, because "reverse" reordering is not
  4953                  supported.  Instead, we need to use the move_it_*
  4954                  family of functions, and move to the previous
  4955                  character starting from the beginning of the visual
  4956                  line.  */
  4957               /* Ignore face changes before the first visible
  4958                  character on this display line.  */
  4959               if (it->current_x <= it->first_visible_x)
  4960                 return it->face_id;
  4961               SAVE_IT (it_copy, *it, it_copy_data);
  4962               /* Implementation note: Since move_it_in_display_line
  4963                  works in the iterator geometry, and thinks the first
  4964                  character is always the leftmost, even in R2L lines,
  4965                  we don't need to distinguish between the R2L and L2R
  4966                  cases here.  */
  4967               current_x = it_copy.current_x;
  4968               move_it_vertically_backward (&it_copy, 0);
  4969               move_it_in_display_line (&it_copy, ZV, current_x - 1, MOVE_TO_X);
  4970               pos = it_copy.current.pos;
  4971               RESTORE_IT (it, it, it_copy_data);
  4972             }
  4973           else
  4974             {
  4975               /* Set charpos to the buffer position of the character
  4976                  that comes after IT's current position in the visual
  4977                  order.  */
  4978               int n = (it->what == IT_COMPOSITION ? it->cmp_it.nchars : 1);
  4979 
  4980               it_copy = *it;
  4981               /* If this is the first display element,
  4982                  bidi_move_to_visually_next will deliver character at
  4983                  current position without moving, so we need to enlarge N.  */
  4984               if (it->bidi_it.first_elt)
  4985                 n++;
  4986               while (n--)
  4987                 bidi_move_to_visually_next (&it_copy.bidi_it);
  4988 
  4989               SET_TEXT_POS (pos,
  4990                             it_copy.bidi_it.charpos, it_copy.bidi_it.bytepos);
  4991             }
  4992         }
  4993       eassert (BEGV <= CHARPOS (pos) && CHARPOS (pos) <= ZV);
  4994 
  4995       /* Determine face for CHARSET_ASCII, or unibyte.  */
  4996       face_id = face_at_buffer_position (it->w,
  4997                                          CHARPOS (pos),
  4998                                          &next_check_charpos,
  4999                                          limit, false, -1, 0);
  5000 
  5001       /* Correct the face for charsets different from ASCII.  Do it
  5002          for the multibyte case only.  The face returned above is
  5003          suitable for unibyte text if current_buffer is unibyte.  */
  5004       if (it->multibyte_p)
  5005         {
  5006           int c = FETCH_MULTIBYTE_CHAR (BYTEPOS (pos));
  5007           struct face *face = FACE_FROM_ID (it->f, face_id);
  5008           face_id = FACE_FOR_CHAR (it->f, face, c, CHARPOS (pos), Qnil);
  5009         }
  5010     }
  5011 
  5012   return face_id;
  5013 }
  5014 
  5015 
  5016 
  5017 /***********************************************************************
  5018                             Invisible text
  5019  ***********************************************************************/
  5020 
  5021 /* Set up iterator IT from invisible properties at its current
  5022    position.  Called from handle_stop.  */
  5023 
  5024 static enum prop_handled
  5025 handle_invisible_prop (struct it *it)
  5026 {
  5027   enum prop_handled handled = HANDLED_NORMALLY;
  5028   int invis;
  5029   Lisp_Object prop;
  5030 
  5031   if (STRINGP (it->string))
  5032     {
  5033       Lisp_Object end_charpos, limit;
  5034 
  5035       /* Get the value of the invisible text property at the
  5036          current position.  Value will be nil if there is no such
  5037          property.  */
  5038       end_charpos = make_fixnum (IT_STRING_CHARPOS (*it));
  5039       prop = Fget_text_property (end_charpos, Qinvisible, it->string);
  5040       invis = TEXT_PROP_MEANS_INVISIBLE (prop);
  5041 
  5042       if (invis != 0 && IT_STRING_CHARPOS (*it) < it->end_charpos)
  5043         {
  5044           /* Record whether we have to display an ellipsis for the
  5045              invisible text.  */
  5046           bool display_ellipsis_p = (invis == 2);
  5047           ptrdiff_t len, endpos;
  5048 
  5049           handled = HANDLED_RECOMPUTE_PROPS;
  5050 
  5051           /* Get the position at which the next visible text can be
  5052              found in IT->string, if any.  */
  5053           endpos = len = SCHARS (it->string);
  5054           XSETINT (limit, len);
  5055           do
  5056             {
  5057               end_charpos
  5058                 = Fnext_single_property_change (end_charpos, Qinvisible,
  5059                                                 it->string, limit);
  5060               /* Since LIMIT is always an integer, so should be the
  5061                  value returned by Fnext_single_property_change.  */
  5062               eassert (FIXNUMP (end_charpos));
  5063               if (FIXNUMP (end_charpos))
  5064                 {
  5065                   endpos = XFIXNAT (end_charpos);
  5066                   prop = Fget_text_property (end_charpos, Qinvisible, it->string);
  5067                   invis = TEXT_PROP_MEANS_INVISIBLE (prop);
  5068                   if (invis == 2)
  5069                     display_ellipsis_p = true;
  5070                 }
  5071               else /* Should never happen; but if it does, exit the loop.  */
  5072                 endpos = len;
  5073             }
  5074           while (invis != 0 && endpos < len);
  5075 
  5076           if (display_ellipsis_p)
  5077             it->ellipsis_p = true;
  5078 
  5079           if (endpos < len)
  5080             {
  5081               /* Text at END_CHARPOS is visible.  Move IT there.  */
  5082               struct text_pos old;
  5083               ptrdiff_t oldpos;
  5084 
  5085               old = it->current.string_pos;
  5086               oldpos = CHARPOS (old);
  5087               if (it->bidi_p)
  5088                 {
  5089                   if (it->bidi_it.first_elt
  5090                       && it->bidi_it.charpos < SCHARS (it->string))
  5091                     bidi_paragraph_init (it->paragraph_embedding,
  5092                                          &it->bidi_it, true);
  5093                   /* Bidi-iterate out of the invisible text.  */
  5094                   do
  5095                     {
  5096                       bidi_move_to_visually_next (&it->bidi_it);
  5097                     }
  5098                   while (oldpos <= it->bidi_it.charpos
  5099                          && it->bidi_it.charpos < endpos
  5100                          && it->bidi_it.charpos < it->bidi_it.string.schars);
  5101 
  5102                   IT_STRING_CHARPOS (*it) = it->bidi_it.charpos;
  5103                   IT_STRING_BYTEPOS (*it) = it->bidi_it.bytepos;
  5104                   if (IT_CHARPOS (*it) >= endpos)
  5105                     it->prev_stop = endpos;
  5106                 }
  5107               else
  5108                 {
  5109                   IT_STRING_CHARPOS (*it) = endpos;
  5110                   compute_string_pos (&it->current.string_pos, old, it->string);
  5111                 }
  5112             }
  5113           else
  5114             {
  5115               /* The rest of the string is invisible.  If this is an
  5116                  overlay string, proceed with the next overlay string
  5117                  or whatever comes and return a character from there.  */
  5118               if (it->current.overlay_string_index >= 0
  5119                   && !display_ellipsis_p)
  5120                 {
  5121                   next_overlay_string (it);
  5122                   /* Don't check for overlay strings when we just
  5123                      finished processing them.  */
  5124                   handled = HANDLED_OVERLAY_STRING_CONSUMED;
  5125                 }
  5126               else
  5127                 {
  5128                   IT_STRING_CHARPOS (*it) = SCHARS (it->string);
  5129                   IT_STRING_BYTEPOS (*it) = SBYTES (it->string);
  5130                 }
  5131             }
  5132         }
  5133     }
  5134   else
  5135     {
  5136       ptrdiff_t newpos, next_stop, start_charpos, tem;
  5137       Lisp_Object pos, overlay;
  5138 
  5139       /* First of all, is there invisible text at this position?  */
  5140       tem = start_charpos = IT_CHARPOS (*it);
  5141       pos = make_fixnum (tem);
  5142       prop = get_char_property_and_overlay (pos, Qinvisible, it->window,
  5143                                             &overlay);
  5144       invis = TEXT_PROP_MEANS_INVISIBLE (prop);
  5145 
  5146       /* If we are on invisible text, skip over it.  */
  5147       if (invis != 0 && start_charpos < it->end_charpos)
  5148         {
  5149           /* Record whether we have to display an ellipsis for the
  5150              invisible text.  */
  5151           bool display_ellipsis_p = invis == 2;
  5152 
  5153           handled = HANDLED_RECOMPUTE_PROPS;
  5154 
  5155           /* Loop skipping over invisible text.  The loop is left at
  5156              ZV or with IT on the first char being visible again.  */
  5157           do
  5158             {
  5159               /* Try to skip some invisible text.  Return value is the
  5160                  position reached which can be equal to where we start
  5161                  if there is nothing invisible there.  This skips both
  5162                  over invisible text properties and overlays with
  5163                  invisible property.  */
  5164               newpos = skip_invisible (tem, &next_stop, ZV, it->window);
  5165 
  5166               /* If we skipped nothing at all we weren't at invisible
  5167                  text in the first place.  If everything to the end of
  5168                  the buffer was skipped, end the loop.  */
  5169               if (newpos == tem || newpos >= ZV)
  5170                 invis = 0;
  5171               else
  5172                 {
  5173                   /* We skipped some characters but not necessarily
  5174                      all there are.  Check if we ended up on visible
  5175                      text.  Fget_char_property returns the property of
  5176                      the char before the given position, i.e. if we
  5177                      get invis = 0, this means that the char at
  5178                      newpos is visible.  */
  5179                   pos = make_fixnum (newpos);
  5180                   prop = Fget_char_property (pos, Qinvisible, it->window);
  5181                   invis = TEXT_PROP_MEANS_INVISIBLE (prop);
  5182                 }
  5183 
  5184               /* If we ended up on invisible text, proceed to
  5185                  skip starting with next_stop.  */
  5186               if (invis != 0)
  5187                 tem = next_stop;
  5188 
  5189               /* If there are adjacent invisible texts, don't lose the
  5190                  second one's ellipsis.  */
  5191               if (invis == 2)
  5192                 display_ellipsis_p = true;
  5193             }
  5194           while (invis != 0);
  5195 
  5196           /* The position newpos is now either ZV or on visible text.  */
  5197           if (it->bidi_p)
  5198             {
  5199               ptrdiff_t bpos = CHAR_TO_BYTE (newpos);
  5200               bool on_newline
  5201                 = bpos == ZV_BYTE || FETCH_BYTE (bpos) == '\n';
  5202               bool after_newline
  5203                 = newpos <= BEGV || FETCH_BYTE (bpos - 1) == '\n';
  5204 
  5205               /* If the invisible text ends on a newline or on a
  5206                  character after a newline, we can avoid the costly,
  5207                  character by character, bidi iteration to NEWPOS, and
  5208                  instead simply reseat the iterator there.  That's
  5209                  because all bidi reordering information is tossed at
  5210                  the newline.  This is a big win for modes that hide
  5211                  complete lines, like Outline, Org, etc.  */
  5212               if (on_newline || after_newline)
  5213                 {
  5214                   struct text_pos tpos;
  5215                   bidi_dir_t pdir = it->bidi_it.paragraph_dir;
  5216 
  5217                   SET_TEXT_POS (tpos, newpos, bpos);
  5218                   reseat_1 (it, tpos, false);
  5219                   /* If we reseat on a newline/ZV, we need to prep the
  5220                      bidi iterator for advancing to the next character
  5221                      after the newline/EOB, keeping the current paragraph
  5222                      direction (so that PRODUCE_GLYPHS does TRT wrt
  5223                      prepending/appending glyphs to a glyph row).  */
  5224                   if (on_newline)
  5225                     {
  5226                       it->bidi_it.first_elt = false;
  5227                       it->bidi_it.paragraph_dir = pdir;
  5228                       it->bidi_it.ch = (bpos == ZV_BYTE) ? -1 : '\n';
  5229                       it->bidi_it.nchars = 1;
  5230                       it->bidi_it.ch_len = 1;
  5231                     }
  5232                 }
  5233               else      /* Must use the slow method.  */
  5234                 {
  5235                   /* With bidi iteration, the region of invisible text
  5236                      could start and/or end in the middle of a
  5237                      non-base embedding level.  Therefore, we need to
  5238                      skip invisible text using the bidi iterator,
  5239                      starting at IT's current position, until we find
  5240                      ourselves outside of the invisible text.
  5241                      Skipping invisible text _after_ bidi iteration
  5242                      avoids affecting the visual order of the
  5243                      displayed text when invisible properties are
  5244                      added or removed.  */
  5245                   if (it->bidi_it.first_elt && it->bidi_it.charpos < ZV)
  5246                     {
  5247                       /* If we were `reseat'ed to a new paragraph,
  5248                          determine the paragraph base direction.  We
  5249                          need to do it now because
  5250                          next_element_from_buffer may not have a
  5251                          chance to do it, if we are going to skip any
  5252                          text at the beginning, which resets the
  5253                          FIRST_ELT flag.  */
  5254                       bidi_paragraph_init (it->paragraph_embedding,
  5255                                            &it->bidi_it, true);
  5256                     }
  5257                   do
  5258                     {
  5259                       bidi_move_to_visually_next (&it->bidi_it);
  5260                     }
  5261                   while (it->stop_charpos <= it->bidi_it.charpos
  5262                          && it->bidi_it.charpos < newpos);
  5263                   IT_CHARPOS (*it) = it->bidi_it.charpos;
  5264                   IT_BYTEPOS (*it) = it->bidi_it.bytepos;
  5265                   /* If we overstepped NEWPOS, record its position in
  5266                      the iterator, so that we skip invisible text if
  5267                      later the bidi iteration lands us in the
  5268                      invisible region again. */
  5269                   if (IT_CHARPOS (*it) >= newpos)
  5270                     it->prev_stop = newpos;
  5271                 }
  5272             }
  5273           else
  5274             {
  5275               IT_CHARPOS (*it) = newpos;
  5276               IT_BYTEPOS (*it) = CHAR_TO_BYTE (newpos);
  5277             }
  5278 
  5279           if (display_ellipsis_p)
  5280             {
  5281               /* Make sure that the glyphs of the ellipsis will get
  5282                  correct `charpos' values.  If we would not update
  5283                  it->position here, the glyphs would belong to the
  5284                  last visible character _before_ the invisible
  5285                  text, which confuses `set_cursor_from_row'.
  5286 
  5287                  We use the last invisible position instead of the
  5288                  first because this way the cursor is always drawn on
  5289                  the first "." of the ellipsis, whenever PT is inside
  5290                  the invisible text.  Otherwise the cursor would be
  5291                  placed _after_ the ellipsis when the point is after the
  5292                  first invisible character.  */
  5293               if (!STRINGP (it->object))
  5294                 {
  5295                   it->position.charpos = newpos - 1;
  5296                   it->position.bytepos = CHAR_TO_BYTE (it->position.charpos);
  5297                 }
  5298             }
  5299 
  5300           /* If there are before-strings at the start of invisible
  5301              text, and the text is invisible because of a text
  5302              property, arrange to show before-strings because 20.x did
  5303              it that way.  (If the text is invisible because of an
  5304              overlay property instead of a text property, this is
  5305              already handled in the overlay code.)  */
  5306           if (NILP (overlay)
  5307               && get_overlay_strings (it, it->stop_charpos))
  5308             {
  5309               handled = HANDLED_RECOMPUTE_PROPS;
  5310               if (it->sp > 0)
  5311                 {
  5312                   it->stack[it->sp - 1].display_ellipsis_p = display_ellipsis_p;
  5313                   /* The call to get_overlay_strings above recomputes
  5314                      it->stop_charpos, but it only considers changes
  5315                      in properties and overlays beyond iterator's
  5316                      current position.  This causes us to miss changes
  5317                      that happen exactly where the invisible property
  5318                      ended.  So we play it safe here and force the
  5319                      iterator to check for potential stop positions
  5320                      immediately after the invisible text.  Note that
  5321                      if get_overlay_strings returns true, it
  5322                      normally also pushed the iterator stack, so we
  5323                      need to update the stop position in the slot
  5324                      below the current one.  */
  5325                   it->stack[it->sp - 1].stop_charpos
  5326                     = CHARPOS (it->stack[it->sp - 1].current.pos);
  5327                 }
  5328             }
  5329           else if (display_ellipsis_p)
  5330             {
  5331               it->ellipsis_p = true;
  5332               /* Let the ellipsis display before
  5333                  considering any properties of the following char.
  5334                  Fixes jasonr@gnu.org 01 Oct 07 bug.  */
  5335               handled = HANDLED_RETURN;
  5336             }
  5337         }
  5338     }
  5339 
  5340   return handled;
  5341 }
  5342 
  5343 
  5344 /* Make iterator IT return `...' next.
  5345    Replaces LEN characters from buffer.  */
  5346 
  5347 static void
  5348 setup_for_ellipsis (struct it *it, int len)
  5349 {
  5350   /* Use the display table definition for `...'.  Invalid glyphs
  5351      will be handled by the method returning elements from dpvec.  */
  5352   if (it->dp && VECTORP (DISP_INVIS_VECTOR (it->dp)))
  5353     {
  5354       struct Lisp_Vector *v = XVECTOR (DISP_INVIS_VECTOR (it->dp));
  5355       it->dpvec = v->contents;
  5356       it->dpend = v->contents + v->header.size;
  5357     }
  5358   else
  5359     {
  5360       /* Default `...'.  */
  5361       it->dpvec = default_invis_vector;
  5362       it->dpend = default_invis_vector + 3;
  5363     }
  5364 
  5365   it->dpvec_char_len = len;
  5366   it->current.dpvec_index = 0;
  5367   it->dpvec_face_id = -1;
  5368 
  5369   /* Use IT->saved_face_id for the ellipsis, so that it has the same
  5370      face as the preceding text.  IT->saved_face_id was set in
  5371      handle_stop to the face of the preceding character, and will be
  5372      different from IT->face_id only if the invisible text skipped in
  5373      handle_invisible_prop has some non-default face on its first
  5374      character.  We thus ignore the face of the invisible text when we
  5375      display the ellipsis.  IT's face is restored in set_iterator_to_next.  */
  5376   if (it->saved_face_id >= 0)
  5377     it->face_id = it->saved_face_id;
  5378 
  5379   /* If the ellipsis represents buffer text, it means we advanced in
  5380      the buffer, so we should no longer ignore overlay strings.  */
  5381   if (it->method == GET_FROM_BUFFER)
  5382     it->ignore_overlay_strings_at_pos_p = false;
  5383 
  5384   it->method = GET_FROM_DISPLAY_VECTOR;
  5385   it->ellipsis_p = true;
  5386 }
  5387 
  5388 
  5389 static Lisp_Object
  5390 find_display_property (Lisp_Object disp, Lisp_Object prop)
  5391 {
  5392   if (NILP (disp))
  5393     return Qnil;
  5394   /* We have a vector of display specs.  */
  5395   if (VECTORP (disp))
  5396     {
  5397       for (ptrdiff_t i = 0; i < ASIZE (disp); i++)
  5398         {
  5399           Lisp_Object elem = AREF (disp, i);
  5400           if (CONSP (elem)
  5401               && CONSP (XCDR (elem))
  5402               && EQ (XCAR (elem), prop))
  5403             return XCAR (XCDR (elem));
  5404         }
  5405       return Qnil;
  5406     }
  5407   /* We have a list of display specs.  */
  5408   else if (CONSP (disp)
  5409            && CONSP (XCAR (disp)))
  5410     {
  5411       while (!NILP (disp))
  5412         {
  5413           Lisp_Object elem = XCAR (disp);
  5414           if (CONSP (elem)
  5415               && CONSP (XCDR (elem))
  5416               && EQ (XCAR (elem), prop))
  5417             return XCAR (XCDR (elem));
  5418 
  5419           /* Check that we have a proper list before going to the next
  5420              element.  */
  5421           if (CONSP (XCDR (disp)))
  5422             disp = XCDR (disp);
  5423           else
  5424             disp = Qnil;
  5425         }
  5426       return Qnil;
  5427     }
  5428   /* A simple display spec.  */
  5429   else if (CONSP (disp)
  5430            && CONSP (XCDR (disp))
  5431            && EQ (XCAR (disp), prop))
  5432     return XCAR (XCDR (disp));
  5433   else
  5434     return Qnil;
  5435 }
  5436 
  5437 static Lisp_Object
  5438 get_display_property (ptrdiff_t bufpos, Lisp_Object prop, Lisp_Object object)
  5439 {
  5440   return find_display_property (Fget_text_property (make_fixnum (bufpos),
  5441                                                     Qdisplay, object),
  5442                                 prop);
  5443 }
  5444 
  5445 static void
  5446 display_min_width (struct it *it, ptrdiff_t bufpos,
  5447                    Lisp_Object object, Lisp_Object width_spec)
  5448 {
  5449   /* We're being called at the end of the `min-width' sequence,
  5450      probably. */
  5451   if (!NILP (it->min_width_property)
  5452       && !EQ (width_spec, it->min_width_property))
  5453     {
  5454       if (!it->glyph_row)
  5455         return;
  5456 
  5457       /* When called from display_string (i.e., the mode line),
  5458          we're being called with a string as the object, and we
  5459          may be called with many sub-strings belonging to the same
  5460          :propertize run. */
  5461       if ((bufpos == 0
  5462            && !EQ (it->min_width_property,
  5463                    get_display_property (0, Qmin_width, object)))
  5464           /* In a buffer -- check that we're really right after the
  5465              sequence of characters covered by this `min-width'.  */
  5466           || (bufpos > BEGV
  5467               && EQ (it->min_width_property,
  5468                      get_display_property (bufpos - 1, Qmin_width, object))))
  5469         {
  5470           Lisp_Object w = Qnil;
  5471           double width;
  5472 #ifdef HAVE_WINDOW_SYSTEM
  5473           if (FRAME_WINDOW_P (it->f))
  5474             {
  5475               struct font *font = NULL;
  5476               struct face *face = FACE_FROM_ID (it->f, it->face_id);
  5477               font = face->font ? face->font : FRAME_FONT (it->f);
  5478               calc_pixel_width_or_height (&width, it,
  5479                                           XCAR (it->min_width_property),
  5480                                           font, true, NULL);
  5481               width -= it->current_x - it->min_width_start;
  5482               w = list1 (make_int (width));
  5483             }
  5484           else
  5485 #endif
  5486             {
  5487               calc_pixel_width_or_height (&width, it,
  5488                                           XCAR (it->min_width_property),
  5489                                           NULL, true, NULL);
  5490               width -= (it->current_x - it->min_width_start) /
  5491                 FRAME_COLUMN_WIDTH (it->f);
  5492               w = make_int (width);
  5493             }
  5494 
  5495           /* Insert the stretch glyph.  */
  5496           it->object = list3 (Qspace, QCwidth, w);
  5497           produce_stretch_glyph (it);
  5498           if (it->area == TEXT_AREA)
  5499             it->current_x += it->pixel_width;
  5500           it->min_width_property = Qnil;
  5501         }
  5502     }
  5503 
  5504   /* We're at the start of a `min-width' sequence -- record the
  5505      position and the property, so that we can later see if we're at
  5506      the end.  */
  5507   if (CONSP (width_spec))
  5508     {
  5509       if (bufpos == BEGV
  5510           /* Mode line (see above).  */
  5511           || (bufpos == 0
  5512               && !EQ (it->min_width_property,
  5513                       get_display_property (0, Qmin_width, object)))
  5514           /* Buffer.  */
  5515           || (bufpos > BEGV
  5516               && !EQ (width_spec,
  5517                       get_display_property (bufpos - 1, Qmin_width, object))))
  5518         {
  5519           it->min_width_property = width_spec;
  5520           it->min_width_start = it->current_x;
  5521         }
  5522     }
  5523 }
  5524 
  5525 DEFUN ("get-display-property", Fget_display_property,
  5526        Sget_display_property, 2, 4, 0,
  5527        doc: /* Get the value of the `display' property PROP at POSITION.
  5528 If OBJECT, this should be a buffer or string where the property is
  5529 fetched from.  If omitted, OBJECT defaults to the current buffer.
  5530 
  5531 If PROPERTIES, look for value of PROP in PROPERTIES instead of the
  5532 properties at POSITION.  */)
  5533   (Lisp_Object position, Lisp_Object prop, Lisp_Object object,
  5534    Lisp_Object properties)
  5535 {
  5536   if (NILP (properties))
  5537     properties = Fget_text_property (position, Qdisplay, object);
  5538   else
  5539     CHECK_LIST (properties);
  5540 
  5541   return find_display_property (properties, prop);
  5542 }
  5543 
  5544 
  5545 
  5546 /***********************************************************************
  5547                             'display' property
  5548  ***********************************************************************/
  5549 
  5550 /* Set up iterator IT from `display' property at its current position.
  5551    Called from handle_stop.
  5552    We return HANDLED_RETURN if some part of the display property
  5553    overrides the display of the buffer text itself.
  5554    Otherwise we return HANDLED_NORMALLY.  */
  5555 
  5556 static enum prop_handled
  5557 handle_display_prop (struct it *it)
  5558 {
  5559   Lisp_Object propval, object, overlay;
  5560   struct text_pos *position;
  5561   ptrdiff_t bufpos;
  5562   /* Nonzero if some property replaces the display of the text itself.  */
  5563   int display_replaced = 0;
  5564 
  5565   if (STRINGP (it->string))
  5566     {
  5567       object = it->string;
  5568       position = &it->current.string_pos;
  5569       bufpos = CHARPOS (it->current.pos);
  5570     }
  5571   else
  5572     {
  5573       XSETWINDOW (object, it->w);
  5574       position = &it->current.pos;
  5575       bufpos = CHARPOS (*position);
  5576     }
  5577 
  5578   /* Reset those iterator values set from display property values.  */
  5579   it->slice.x = it->slice.y = it->slice.width = it->slice.height = Qnil;
  5580   it->space_width = Qnil;
  5581   it->font_height = Qnil;
  5582   it->voffset = 0;
  5583 
  5584   /* We don't support recursive `display' properties, i.e. string
  5585      values that have a string `display' property, that have a string
  5586      `display' property etc.  */
  5587   if (!it->string_from_display_prop_p)
  5588     it->area = TEXT_AREA;
  5589 
  5590   propval = get_char_property_and_overlay (make_fixnum (position->charpos),
  5591                                            Qdisplay, object, &overlay);
  5592 
  5593   /* Rest of the code must have OBJECT be either a string or a buffer.  */
  5594   if (!STRINGP (it->string))
  5595     object = it->w->contents;
  5596 
  5597   /* Handle min-width ends. */
  5598   if (!NILP (it->min_width_property)
  5599       && NILP (find_display_property (propval, Qmin_width)))
  5600     display_min_width (it, bufpos, object, Qnil);
  5601 
  5602   if (NILP (propval))
  5603     return HANDLED_NORMALLY;
  5604   /* Now OVERLAY is the overlay that gave us this property, or nil
  5605      if it was a text property.  */
  5606 
  5607   display_replaced = handle_display_spec (it, propval, object, overlay,
  5608                                           position, bufpos,
  5609                                           FRAME_WINDOW_P (it->f));
  5610   return display_replaced != 0 ? HANDLED_RETURN : HANDLED_NORMALLY;
  5611 }
  5612 
  5613 /* Subroutine of handle_display_prop.  Returns non-zero if the display
  5614    specification in SPEC is a replacing specification, i.e. it would
  5615    replace the text covered by `display' property with something else,
  5616    such as an image or a display string.  If SPEC includes any kind or
  5617    `(space ...) specification, the value is 2; this is used by
  5618    compute_display_string_pos, which see.
  5619 
  5620    See handle_single_display_spec for documentation of arguments.
  5621    FRAME_WINDOW_P is true if the window being redisplayed is on a
  5622    GUI frame; this argument is used only if IT is NULL, see below.
  5623 
  5624    IT can be NULL, if this is called by the bidi reordering code
  5625    through compute_display_string_pos, which see.  In that case, this
  5626    function only examines SPEC, but does not otherwise "handle" it, in
  5627    the sense that it doesn't set up members of IT from the display
  5628    spec.  */
  5629 static int
  5630 handle_display_spec (struct it *it, Lisp_Object spec, Lisp_Object object,
  5631                      Lisp_Object overlay, struct text_pos *position,
  5632                      ptrdiff_t bufpos, bool frame_window_p)
  5633 {
  5634   int replacing = 0;
  5635   bool enable_eval = true;
  5636 
  5637   /* Support (disable-eval PROP) which is used by enriched.el.  */
  5638   if (CONSP (spec) && EQ (XCAR (spec), Qdisable_eval))
  5639     {
  5640       enable_eval = false;
  5641       spec = CONSP (XCDR (spec)) ? XCAR (XCDR (spec)) : Qnil;
  5642     }
  5643 
  5644   if (CONSP (spec)
  5645       /* Simple specifications.  */
  5646       && !EQ (XCAR (spec), Qimage)
  5647 #ifdef HAVE_XWIDGETS
  5648       && !EQ (XCAR (spec), Qxwidget)
  5649 #endif
  5650       && !EQ (XCAR (spec), Qspace)
  5651       && !EQ (XCAR (spec), Qwhen)
  5652       && !EQ (XCAR (spec), Qslice)
  5653       && !EQ (XCAR (spec), Qspace_width)
  5654       && !EQ (XCAR (spec), Qheight)
  5655       && !EQ (XCAR (spec), Qraise)
  5656       /* Marginal area specifications.  */
  5657       && !(CONSP (XCAR (spec)) && EQ (XCAR (XCAR (spec)), Qmargin))
  5658       && !EQ (XCAR (spec), Qleft_fringe)
  5659       && !EQ (XCAR (spec), Qright_fringe)
  5660       && !EQ (XCAR (spec), Qmin_width)
  5661       && !NILP (XCAR (spec)))
  5662     {
  5663       for (; CONSP (spec); spec = XCDR (spec))
  5664         {
  5665           int rv = handle_single_display_spec (it, XCAR (spec), object,
  5666                                                overlay, position, bufpos,
  5667                                                replacing, frame_window_p,
  5668                                                enable_eval);
  5669           if (rv != 0)
  5670             {
  5671               replacing = rv;
  5672               /* If some text in a string is replaced, `position' no
  5673                  longer points to the position of `object'.  */
  5674               if (!it || STRINGP (object))
  5675                 break;
  5676             }
  5677         }
  5678     }
  5679   else if (VECTORP (spec))
  5680     {
  5681       ptrdiff_t i;
  5682       for (i = 0; i < ASIZE (spec); ++i)
  5683         {
  5684           int rv = handle_single_display_spec (it, AREF (spec, i), object,
  5685                                                overlay, position, bufpos,
  5686                                                replacing, frame_window_p,
  5687                                                enable_eval);
  5688           if (rv != 0)
  5689             {
  5690               replacing = rv;
  5691               /* If some text in a string is replaced, `position' no
  5692                  longer points to the position of `object'.  */
  5693               if (!it || STRINGP (object))
  5694                 break;
  5695             }
  5696         }
  5697     }
  5698   else
  5699     replacing = handle_single_display_spec (it, spec, object, overlay, position,
  5700                                             bufpos, 0, frame_window_p,
  5701                                             enable_eval);
  5702   return replacing;
  5703 }
  5704 
  5705 /* Value is the position of the end of the `display' property starting
  5706    at START_POS in OBJECT.  */
  5707 
  5708 static struct text_pos
  5709 display_prop_end (struct it *it, Lisp_Object object, struct text_pos start_pos)
  5710 {
  5711   Lisp_Object end;
  5712   struct text_pos end_pos;
  5713 
  5714   end = Fnext_single_char_property_change (make_fixnum (CHARPOS (start_pos)),
  5715                                            Qdisplay, object, Qnil);
  5716   CHARPOS (end_pos) = XFIXNAT (end);
  5717   if (STRINGP (object))
  5718     compute_string_pos (&end_pos, start_pos, it->string);
  5719   else
  5720     BYTEPOS (end_pos) = CHAR_TO_BYTE (XFIXNAT (end));
  5721 
  5722   return end_pos;
  5723 }
  5724 
  5725 
  5726 /* Set up IT from a single `display' property specification SPEC.  OBJECT
  5727    is the object in which the `display' property was found.  *POSITION
  5728    is the position in OBJECT at which the `display' property was found.
  5729    BUFPOS is the buffer position of OBJECT (different from POSITION if
  5730    OBJECT is not a buffer).  DISPLAY_REPLACED non-zero means that we
  5731    previously saw a display specification which already replaced text
  5732    display with something else, for example an image; we ignore such
  5733    properties after the first one has been processed.
  5734 
  5735    OVERLAY is the overlay this `display' property came from,
  5736    or nil if it was a text property.
  5737 
  5738    If SPEC is a `space' or `image' specification, and in some other
  5739    cases too, set *POSITION to the position where the `display'
  5740    property ends.
  5741 
  5742    If IT is NULL, only examine the property specification in SPEC, but
  5743    don't set up IT.  In that case, FRAME_WINDOW_P means SPEC
  5744    is intended to be displayed in a window on a GUI frame.
  5745 
  5746    Enable evaluation of Lisp forms only if ENABLE_EVAL_P is true.
  5747 
  5748    Value is non-zero if something was found which replaces the display
  5749    of buffer or string text.  */
  5750 
  5751 static int
  5752 handle_single_display_spec (struct it *it, Lisp_Object spec, Lisp_Object object,
  5753                             Lisp_Object overlay, struct text_pos *position,
  5754                             ptrdiff_t bufpos, int display_replaced,
  5755                             bool frame_window_p, bool enable_eval_p)
  5756 {
  5757   Lisp_Object form;
  5758   Lisp_Object location, value;
  5759   struct text_pos start_pos = *position;
  5760   void *itdata = NULL;
  5761 
  5762   /* If SPEC is a list of the form `(when FORM . VALUE)', evaluate FORM.
  5763      If the result is non-nil, use VALUE instead of SPEC.  */
  5764   form = Qt;
  5765   if (CONSP (spec) && EQ (XCAR (spec), Qwhen))
  5766     {
  5767       spec = XCDR (spec);
  5768       if (!CONSP (spec))
  5769         return 0;
  5770       form = XCAR (spec);
  5771       spec = XCDR (spec);
  5772     }
  5773 
  5774   if (!NILP (form) && !EQ (form, Qt) && !enable_eval_p)
  5775     form = Qnil;
  5776   if (!NILP (form) && !EQ (form, Qt))
  5777     {
  5778       specpdl_ref count = SPECPDL_INDEX ();
  5779 
  5780       /* Bind `object' to the object having the `display' property, a
  5781          buffer or string.  Bind `position' to the position in the
  5782          object where the property was found, and `buffer-position'
  5783          to the current position in the buffer.  */
  5784 
  5785       if (NILP (object))
  5786         XSETBUFFER (object, current_buffer);
  5787       specbind (Qobject, object);
  5788       specbind (Qposition, make_fixnum (CHARPOS (*position)));
  5789       specbind (Qbuffer_position, make_fixnum (bufpos));
  5790       /* Save and restore the bidi cache, since FORM could be crazy
  5791          enough to re-enter redisplay, e.g., by calling 'message'.  */
  5792       itdata = bidi_shelve_cache ();
  5793       form = safe_eval (form);
  5794       bidi_unshelve_cache (itdata, false);
  5795       form = unbind_to (count, form);
  5796     }
  5797 
  5798   if (NILP (form))
  5799     return 0;
  5800 
  5801   /* Handle `(height HEIGHT)' specifications.  */
  5802   if (CONSP (spec)
  5803       && EQ (XCAR (spec), Qheight)
  5804       && CONSP (XCDR (spec)))
  5805     {
  5806       if (it)
  5807         {
  5808           if (!FRAME_WINDOW_P (it->f))
  5809             return 0;
  5810 
  5811           it->font_height = XCAR (XCDR (spec));
  5812           if (!NILP (it->font_height))
  5813             {
  5814               int new_height = -1;
  5815 
  5816               if (CONSP (it->font_height)
  5817                   && (EQ (XCAR (it->font_height), Qplus)
  5818                       || EQ (XCAR (it->font_height), Qminus))
  5819                   && CONSP (XCDR (it->font_height))
  5820                   && RANGED_FIXNUMP (0, XCAR (XCDR (it->font_height)), INT_MAX))
  5821                 {
  5822                   /* `(+ N)' or `(- N)' where N is an integer.  */
  5823                   int steps = XFIXNUM (XCAR (XCDR (it->font_height)));
  5824                   if (EQ (XCAR (it->font_height), Qplus))
  5825                     steps = - steps;
  5826                   it->face_id = smaller_face (it->f, it->face_id, steps);
  5827                 }
  5828               else if (FUNCTIONP (it->font_height) && enable_eval_p)
  5829                 {
  5830                   /* Call function with current height as argument.
  5831                      Value is the new height.  */
  5832                   struct face *face = FACE_FROM_ID (it->f, it->face_id);
  5833                   Lisp_Object height;
  5834                   itdata = bidi_shelve_cache ();
  5835                   height = safe_call1 (it->font_height,
  5836                                        face->lface[LFACE_HEIGHT_INDEX]);
  5837                   bidi_unshelve_cache (itdata, false);
  5838                   if (NUMBERP (height))
  5839                     new_height = XFLOATINT (height);
  5840                 }
  5841               else if (NUMBERP (it->font_height))
  5842                 {
  5843                   /* Value is a multiple of the canonical char height.  */
  5844                   struct face *f;
  5845 
  5846                   f = FACE_FROM_ID (it->f,
  5847                                     lookup_basic_face (it->w, it->f, DEFAULT_FACE_ID));
  5848                   new_height = (XFLOATINT (it->font_height)
  5849                                 * XFIXNUM (f->lface[LFACE_HEIGHT_INDEX]));
  5850                 }
  5851               else if (enable_eval_p)
  5852                 {
  5853                   /* Evaluate IT->font_height with `height' bound to the
  5854                      current specified height to get the new height.  */
  5855                   specpdl_ref count = SPECPDL_INDEX ();
  5856                   struct face *face = FACE_FROM_ID (it->f, it->face_id);
  5857 
  5858                   specbind (Qheight, face->lface[LFACE_HEIGHT_INDEX]);
  5859                   itdata = bidi_shelve_cache ();
  5860                   value = safe_eval (it->font_height);
  5861                   bidi_unshelve_cache (itdata, false);
  5862                   value = unbind_to (count, value);
  5863 
  5864                   if (NUMBERP (value))
  5865                     new_height = XFLOATINT (value);
  5866                 }
  5867 
  5868               if (new_height > 0)
  5869                 it->face_id = face_with_height (it->f, it->face_id, new_height);
  5870             }
  5871         }
  5872 
  5873       return 0;
  5874     }
  5875 
  5876   /* Handle `(space-width WIDTH)'.  */
  5877   if (CONSP (spec)
  5878       && EQ (XCAR (spec), Qspace_width)
  5879       && CONSP (XCDR (spec)))
  5880     {
  5881       if (it)
  5882         {
  5883           if (!FRAME_WINDOW_P (it->f))
  5884             return 0;
  5885 
  5886           value = XCAR (XCDR (spec));
  5887           if (NUMBERP (value) && XFLOATINT (value) > 0)
  5888             it->space_width = value;
  5889         }
  5890 
  5891       return 0;
  5892     }
  5893 
  5894   /* Handle `(min-width (WIDTH))'.  */
  5895   if (CONSP (spec)
  5896       && EQ (XCAR (spec), Qmin_width)
  5897       && CONSP (XCDR (spec))
  5898       && CONSP (XCAR (XCDR (spec))))
  5899     {
  5900       if (it)
  5901         display_min_width (it, bufpos, object, XCAR (XCDR (spec)));
  5902       return 0;
  5903     }
  5904 
  5905   /* Handle `(slice X Y WIDTH HEIGHT)'.  */
  5906   if (CONSP (spec)
  5907       && EQ (XCAR (spec), Qslice))
  5908     {
  5909       Lisp_Object tem;
  5910 
  5911       if (it)
  5912         {
  5913           if (!FRAME_WINDOW_P (it->f))
  5914             return 0;
  5915 
  5916           if (tem = XCDR (spec), CONSP (tem))
  5917             {
  5918               it->slice.x = XCAR (tem);
  5919               if (tem = XCDR (tem), CONSP (tem))
  5920                 {
  5921                   it->slice.y = XCAR (tem);
  5922                   if (tem = XCDR (tem), CONSP (tem))
  5923                     {
  5924                       it->slice.width = XCAR (tem);
  5925                       if (tem = XCDR (tem), CONSP (tem))
  5926                         it->slice.height = XCAR (tem);
  5927                     }
  5928                 }
  5929             }
  5930         }
  5931 
  5932       return 0;
  5933     }
  5934 
  5935   /* Handle `(raise FACTOR)'.  */
  5936   if (CONSP (spec)
  5937       && EQ (XCAR (spec), Qraise)
  5938       && CONSP (XCDR (spec)))
  5939     {
  5940       if (it)
  5941         {
  5942           if (!FRAME_WINDOW_P (it->f))
  5943             return 0;
  5944 
  5945 #ifdef HAVE_WINDOW_SYSTEM
  5946           value = XCAR (XCDR (spec));
  5947           if (NUMBERP (value))
  5948             {
  5949               struct face *face = FACE_FROM_ID (it->f, it->face_id);
  5950               it->voffset = - (XFLOATINT (value)
  5951                                * (normal_char_height (face->font, -1)));
  5952             }
  5953 #endif /* HAVE_WINDOW_SYSTEM */
  5954         }
  5955 
  5956       return 0;
  5957     }
  5958 
  5959   /* Don't handle the other kinds of display specifications
  5960      inside a string that we got from a `display' property.  */
  5961   if (it && it->string_from_display_prop_p)
  5962     return 0;
  5963 
  5964   /* Characters having this form of property are not displayed, so
  5965      we have to find the end of the property.  */
  5966   if (it)
  5967     {
  5968       start_pos = *position;
  5969       *position = display_prop_end (it, object, start_pos);
  5970       /* If the display property comes from an overlay, don't consider
  5971          any potential stop_charpos values before the end of that
  5972          overlay.  Since display_prop_end will happily find another
  5973          'display' property coming from some other overlay or text
  5974          property on buffer positions before this overlay's end, we
  5975          need to ignore them, or else we risk displaying this
  5976          overlay's display string/image twice.  */
  5977       if (!NILP (overlay))
  5978         {
  5979           ptrdiff_t ovendpos = OVERLAY_END (overlay);
  5980 
  5981           /* Some borderline-sane Lisp might call us with the current
  5982              buffer narrowed so that overlay-end is outside the
  5983              POINT_MIN..POINT_MAX region, which will then cause
  5984              various assertion violations and crashes down the road,
  5985              starting with pop_it when it will attempt to use POSITION
  5986              set below.  Prevent that.  */
  5987           ovendpos = clip_to_bounds (BEGV, ovendpos, ZV);
  5988 
  5989           if (ovendpos > CHARPOS (*position))
  5990             SET_TEXT_POS (*position, ovendpos, CHAR_TO_BYTE (ovendpos));
  5991         }
  5992     }
  5993   value = Qnil;
  5994 
  5995   /* Stop the scan at that end position--we assume that all
  5996      text properties change there.  */
  5997   if (it)
  5998     it->stop_charpos = position->charpos;
  5999 
  6000   /* Handle `(left-fringe BITMAP [FACE])'
  6001      and `(right-fringe BITMAP [FACE])'.  */
  6002   if (CONSP (spec)
  6003       && (EQ (XCAR (spec), Qleft_fringe)
  6004           || EQ (XCAR (spec), Qright_fringe))
  6005       && CONSP (XCDR (spec)))
  6006     {
  6007       if (it)
  6008         {
  6009           if (!FRAME_WINDOW_P (it->f))
  6010             /* If we return here, POSITION has been advanced
  6011                across the text with this property.  */
  6012             {
  6013               /* Synchronize the bidi iterator with POSITION.  This is
  6014                  needed because we are not going to push the iterator
  6015                  on behalf of this display property, so there will be
  6016                  no pop_it call to do this synchronization for us.  */
  6017               if (it->bidi_p)
  6018                 {
  6019                   it->position = *position;
  6020                   iterate_out_of_display_property (it);
  6021                   *position = it->position;
  6022                 }
  6023               return 1;
  6024             }
  6025         }
  6026       else if (!frame_window_p)
  6027         return 1;
  6028 
  6029 #ifdef HAVE_WINDOW_SYSTEM
  6030       value = XCAR (XCDR (spec));
  6031       int fringe_bitmap = SYMBOLP (value) ? lookup_fringe_bitmap (value) : 0;
  6032       if (! fringe_bitmap)
  6033         /* If we return here, POSITION has been advanced
  6034            across the text with this property.  */
  6035         {
  6036           if (it && it->bidi_p)
  6037             {
  6038               it->position = *position;
  6039               iterate_out_of_display_property (it);
  6040               *position = it->position;
  6041             }
  6042           return 1;
  6043         }
  6044 
  6045       if (it)
  6046         {
  6047           int face_id = lookup_basic_face (it->w, it->f, DEFAULT_FACE_ID);
  6048 
  6049           if (CONSP (XCDR (XCDR (spec))))
  6050             {
  6051               Lisp_Object face_name = XCAR (XCDR (XCDR (spec)));
  6052               int face_id2;
  6053               /* Don't allow quitting from lookup_derived_face, for when
  6054                  we are displaying a non-selected window, and the buffer's
  6055                  point was temporarily moved to the window-point.  */
  6056               specpdl_ref count1 = SPECPDL_INDEX ();
  6057               specbind (Qinhibit_quit, Qt);
  6058               face_id2 = lookup_derived_face (it->w, it->f, face_name,
  6059                                               FRINGE_FACE_ID, false);
  6060               unbind_to (count1, Qnil);
  6061               if (face_id2 >= 0)
  6062                 face_id = face_id2;
  6063             }
  6064 
  6065           /* Save current settings of IT so that we can restore them
  6066              when we are finished with the glyph property value.  */
  6067           push_it (it, position);
  6068 
  6069           it->area = TEXT_AREA;
  6070           it->what = IT_IMAGE;
  6071           it->image_id = -1; /* no image */
  6072           it->position = start_pos;
  6073           it->object = NILP (object) ? it->w->contents : object;
  6074           it->method = GET_FROM_IMAGE;
  6075           it->from_overlay = Qnil;
  6076           it->face_id = face_id;
  6077           it->from_disp_prop_p = true;
  6078 
  6079           /* Say that we haven't consumed the characters with
  6080              `display' property yet.  The call to pop_it in
  6081              set_iterator_to_next will clean this up.  */
  6082           *position = start_pos;
  6083 
  6084           if (EQ (XCAR (spec), Qleft_fringe))
  6085             {
  6086               it->left_user_fringe_bitmap = fringe_bitmap;
  6087               it->left_user_fringe_face_id = face_id;
  6088             }
  6089           else
  6090             {
  6091               it->right_user_fringe_bitmap = fringe_bitmap;
  6092               it->right_user_fringe_face_id = face_id;
  6093             }
  6094         }
  6095 #endif /* HAVE_WINDOW_SYSTEM */
  6096       return 1;
  6097     }
  6098 
  6099   /* Prepare to handle `((margin left-margin) ...)',
  6100      `((margin right-margin) ...)' and `((margin nil) ...)'
  6101      prefixes for display specifications.  */
  6102   location = Qunbound;
  6103   if (CONSP (spec) && CONSP (XCAR (spec)))
  6104     {
  6105       Lisp_Object tem;
  6106 
  6107       value = XCDR (spec);
  6108       if (CONSP (value))
  6109         value = XCAR (value);
  6110 
  6111       tem = XCAR (spec);
  6112       if (EQ (XCAR (tem), Qmargin)
  6113           && (tem = XCDR (tem),
  6114               tem = CONSP (tem) ? XCAR (tem) : Qnil,
  6115               (NILP (tem)
  6116                || EQ (tem, Qleft_margin)
  6117                || EQ (tem, Qright_margin))))
  6118         location = tem;
  6119     }
  6120 
  6121   if (BASE_EQ (location, Qunbound))
  6122     {
  6123       location = Qnil;
  6124       value = spec;
  6125     }
  6126 
  6127   /* After this point, VALUE is the property after any
  6128      margin prefix has been stripped.  It must be a string,
  6129      an image specification, or `(space ...)'.
  6130 
  6131      LOCATION specifies where to display: `left-margin',
  6132      `right-margin' or nil.  */
  6133 
  6134   bool valid_p = (STRINGP (value)
  6135 #ifdef HAVE_WINDOW_SYSTEM
  6136                   || ((it ? FRAME_WINDOW_P (it->f) : frame_window_p)
  6137                       && valid_image_p (value))
  6138 #endif /* not HAVE_WINDOW_SYSTEM */
  6139              || (CONSP (value) && EQ (XCAR (value), Qspace))
  6140              || ((it ? FRAME_WINDOW_P (it->f) : frame_window_p)
  6141                  && valid_xwidget_spec_p (value)));
  6142 
  6143   if (valid_p && display_replaced == 0)
  6144     {
  6145       int retval = 1;
  6146 
  6147       if (!it)
  6148         {
  6149           /* Callers need to know whether the display spec is any kind
  6150              of `(space ...)' spec that is about to affect text-area
  6151              display.  */
  6152           if (CONSP (value) && EQ (XCAR (value), Qspace) && NILP (location))
  6153             retval = 2;
  6154           return retval;
  6155         }
  6156 
  6157       /* Save current settings of IT so that we can restore them
  6158          when we are finished with the glyph property value.  */
  6159       push_it (it, position);
  6160       it->from_overlay = overlay;
  6161       it->from_disp_prop_p = true;
  6162 
  6163       if (NILP (location))
  6164         it->area = TEXT_AREA;
  6165       else if (EQ (location, Qleft_margin))
  6166         it->area = LEFT_MARGIN_AREA;
  6167       else
  6168         it->area = RIGHT_MARGIN_AREA;
  6169 
  6170       if (STRINGP (value))
  6171         {
  6172           it->string = value;
  6173           it->multibyte_p = STRING_MULTIBYTE (it->string);
  6174           it->current.overlay_string_index = -1;
  6175           IT_STRING_CHARPOS (*it) = IT_STRING_BYTEPOS (*it) = 0;
  6176           it->end_charpos = it->string_nchars = SCHARS (it->string);
  6177           it->method = GET_FROM_STRING;
  6178           it->stop_charpos = 0;
  6179           it->prev_stop = 0;
  6180           it->base_level_stop = 0;
  6181           it->string_from_display_prop_p = true;
  6182           it->cmp_it.id = -1;
  6183           /* Say that we haven't consumed the characters with
  6184              `display' property yet.  The call to pop_it in
  6185              set_iterator_to_next will clean this up.  */
  6186           if (BUFFERP (object))
  6187             *position = start_pos;
  6188 
  6189           /* Force paragraph direction to be that of the parent
  6190              object.  If the parent object's paragraph direction is
  6191              not yet determined, default to L2R.  */
  6192           if (it->bidi_p && it->bidi_it.paragraph_dir == R2L)
  6193             it->paragraph_embedding = it->bidi_it.paragraph_dir;
  6194           else
  6195             it->paragraph_embedding = L2R;
  6196 
  6197           /* Set up the bidi iterator for this display string.  */
  6198           if (it->bidi_p)
  6199             {
  6200               it->bidi_it.string.lstring = it->string;
  6201               it->bidi_it.string.s = NULL;
  6202               it->bidi_it.string.schars = it->end_charpos;
  6203               it->bidi_it.string.bufpos = bufpos;
  6204               it->bidi_it.string.from_disp_str = true;
  6205               it->bidi_it.string.unibyte = !it->multibyte_p;
  6206               it->bidi_it.w = it->w;
  6207               bidi_init_it (0, 0, FRAME_WINDOW_P (it->f), &it->bidi_it);
  6208             }
  6209         }
  6210       else if (CONSP (value) && EQ (XCAR (value), Qspace))
  6211         {
  6212           it->method = GET_FROM_STRETCH;
  6213           it->object = value;
  6214           *position = it->position = start_pos;
  6215           retval = 1 + (it->area == TEXT_AREA);
  6216         }
  6217       else if (valid_xwidget_spec_p (value))
  6218         {
  6219           it->what = IT_XWIDGET;
  6220           it->method = GET_FROM_XWIDGET;
  6221           it->position = start_pos;
  6222           it->object = NILP (object) ? it->w->contents : object;
  6223           *position = start_pos;
  6224           it->xwidget = lookup_xwidget (value);
  6225         }
  6226 #ifdef HAVE_WINDOW_SYSTEM
  6227       else
  6228         {
  6229           specpdl_ref count = SPECPDL_INDEX ();
  6230 
  6231           it->what = IT_IMAGE;
  6232           /* Don't allow quitting from lookup_image, for when we are
  6233              displaying a non-selected window, and the buffer's point
  6234              was temporarily moved to the window-point.  */
  6235           specbind (Qinhibit_quit, Qt);
  6236           it->image_id = lookup_image (it->f, value, it->face_id);
  6237           unbind_to (count, Qnil);
  6238           it->position = start_pos;
  6239           it->object = NILP (object) ? it->w->contents : object;
  6240           it->method = GET_FROM_IMAGE;
  6241 
  6242           /* Say that we haven't consumed the characters with
  6243              `display' property yet.  The call to pop_it in
  6244              set_iterator_to_next will clean this up.  */
  6245           *position = start_pos;
  6246         }
  6247 #endif /* HAVE_WINDOW_SYSTEM */
  6248 
  6249       return retval;
  6250     }
  6251 
  6252   /* Invalid property or property not supported.  Restore
  6253      POSITION to what it was before.  */
  6254   *position = start_pos;
  6255   return 0;
  6256 }
  6257 
  6258 /* Check if PROP is a display property value whose text should be
  6259    treated as intangible.  OVERLAY is the overlay from which PROP
  6260    came, or nil if it came from a text property.  CHARPOS and BYTEPOS
  6261    specify the buffer position covered by PROP.  */
  6262 
  6263 bool
  6264 display_prop_intangible_p (Lisp_Object prop, Lisp_Object overlay,
  6265                            ptrdiff_t charpos, ptrdiff_t bytepos)
  6266 {
  6267   bool frame_window_p = FRAME_WINDOW_P (XFRAME (selected_frame));
  6268   struct text_pos position;
  6269 
  6270   SET_TEXT_POS (position, charpos, bytepos);
  6271   return (handle_display_spec (NULL, prop, Qnil, overlay,
  6272                                &position, charpos, frame_window_p)
  6273           != 0);
  6274 }
  6275 
  6276 
  6277 /* Return true if PROP is a display sub-property value containing STRING.
  6278 
  6279    Implementation note: this and the following function are really
  6280    special cases of handle_display_spec and
  6281    handle_single_display_spec, and should ideally use the same code.
  6282    Until they do, these two pairs must be consistent and must be
  6283    modified in sync.  */
  6284 
  6285 static bool
  6286 single_display_spec_string_p (Lisp_Object prop, Lisp_Object string)
  6287 {
  6288   if (EQ (string, prop))
  6289     return true;
  6290 
  6291   /* Skip over `when FORM'.  */
  6292   if (CONSP (prop) && EQ (XCAR (prop), Qwhen))
  6293     {
  6294       prop = XCDR (prop);
  6295       if (!CONSP (prop))
  6296         return false;
  6297       /* Actually, the condition following `when' should be eval'ed,
  6298          like handle_single_display_spec does, and we should return
  6299          false if it evaluates to nil.  However, this function is
  6300          called only when the buffer was already displayed and some
  6301          glyph in the glyph matrix was found to come from a display
  6302          string.  Therefore, the condition was already evaluated, and
  6303          the result was non-nil, otherwise the display string wouldn't
  6304          have been displayed and we would have never been called for
  6305          this property.  Thus, we can skip the evaluation and assume
  6306          its result is non-nil.  */
  6307       prop = XCDR (prop);
  6308     }
  6309 
  6310   if (CONSP (prop))
  6311     /* Skip over `margin LOCATION'.  */
  6312     if (EQ (XCAR (prop), Qmargin))
  6313       {
  6314         prop = XCDR (prop);
  6315         if (!CONSP (prop))
  6316           return false;
  6317 
  6318         prop = XCDR (prop);
  6319         if (!CONSP (prop))
  6320           return false;
  6321       }
  6322 
  6323   return EQ (prop, string) || (CONSP (prop) && EQ (XCAR (prop), string));
  6324 }
  6325 
  6326 
  6327 /* Return true if STRING appears in the `display' property PROP.  */
  6328 
  6329 static bool
  6330 display_prop_string_p (Lisp_Object prop, Lisp_Object string)
  6331 {
  6332   if (CONSP (prop)
  6333       && !EQ (XCAR (prop), Qwhen)
  6334       && !(CONSP (XCAR (prop)) && EQ (Qmargin, XCAR (XCAR (prop)))))
  6335     {
  6336       /* A list of sub-properties.  */
  6337       while (CONSP (prop))
  6338         {
  6339           if (single_display_spec_string_p (XCAR (prop), string))
  6340             return true;
  6341           prop = XCDR (prop);
  6342         }
  6343     }
  6344   else if (VECTORP (prop))
  6345     {
  6346       /* A vector of sub-properties.  */
  6347       ptrdiff_t i;
  6348       for (i = 0; i < ASIZE (prop); ++i)
  6349         if (single_display_spec_string_p (AREF (prop, i), string))
  6350           return true;
  6351     }
  6352   else
  6353     return single_display_spec_string_p (prop, string);
  6354 
  6355   return false;
  6356 }
  6357 
  6358 /* Look for STRING in overlays and text properties in the current
  6359    buffer, between character positions FROM and TO (excluding TO).
  6360    BACK_P means look back (in this case, TO is supposed to be
  6361    less than FROM).
  6362    Value is the first character position where STRING was found, or
  6363    zero if it wasn't found before hitting TO.
  6364 
  6365    This function may only use code that doesn't eval because it is
  6366    called asynchronously from note_mouse_highlight.  */
  6367 
  6368 static ptrdiff_t
  6369 string_buffer_position_lim (Lisp_Object string,
  6370                             ptrdiff_t from, ptrdiff_t to, bool back_p)
  6371 {
  6372   Lisp_Object limit, prop, pos;
  6373   bool found = false;
  6374 
  6375   pos = make_fixnum (max (from, BEGV));
  6376 
  6377   if (!back_p)  /* looking forward */
  6378     {
  6379       limit = make_fixnum (min (to, ZV));
  6380       while (!found && !EQ (pos, limit))
  6381         {
  6382           prop = Fget_char_property (pos, Qdisplay, Qnil);
  6383           if (!NILP (prop) && display_prop_string_p (prop, string))
  6384             found = true;
  6385           else
  6386             pos = Fnext_single_char_property_change (pos, Qdisplay, Qnil,
  6387                                                      limit);
  6388         }
  6389     }
  6390   else          /* looking back */
  6391     {
  6392       limit = make_fixnum (max (to, BEGV));
  6393       while (!found && !EQ (pos, limit))
  6394         {
  6395           prop = Fget_char_property (pos, Qdisplay, Qnil);
  6396           if (!NILP (prop) && display_prop_string_p (prop, string))
  6397             found = true;
  6398           else
  6399             pos = Fprevious_single_char_property_change (pos, Qdisplay, Qnil,
  6400                                                          limit);
  6401         }
  6402     }
  6403 
  6404   return found ? XFIXNUM (pos) : 0;
  6405 }
  6406 
  6407 /* Determine which buffer position in current buffer STRING comes from.
  6408    AROUND_CHARPOS is an approximate position where it could come from.
  6409    Value is the buffer position or 0 if it couldn't be determined.
  6410 
  6411    This function is necessary because we don't record buffer positions
  6412    in glyphs generated from strings (to keep struct glyph small).
  6413    This function may only use code that doesn't eval because it is
  6414    called asynchronously from note_mouse_highlight.  */
  6415 
  6416 static ptrdiff_t
  6417 string_buffer_position (Lisp_Object string, ptrdiff_t around_charpos)
  6418 {
  6419   const int MAX_DISTANCE = 1000;
  6420   ptrdiff_t forward_limit = min (around_charpos + MAX_DISTANCE, ZV);
  6421   ptrdiff_t found = string_buffer_position_lim (string, around_charpos,
  6422                                                 forward_limit, false);
  6423 
  6424   if (!found)
  6425     {
  6426       ptrdiff_t backward_limit = max (around_charpos - MAX_DISTANCE, BEGV);
  6427       found = string_buffer_position_lim (string, around_charpos,
  6428                                           backward_limit, true);
  6429     }
  6430   return found;
  6431 }
  6432 
  6433 
  6434 
  6435 /***********************************************************************
  6436                         `composition' property
  6437  ***********************************************************************/
  6438 
  6439 /* Set up iterator IT from `composition' property at its current
  6440    position.  Called from handle_stop.  */
  6441 
  6442 static enum prop_handled
  6443 handle_composition_prop (struct it *it)
  6444 {
  6445   Lisp_Object prop, string;
  6446   ptrdiff_t pos, pos_byte, start, end;
  6447 
  6448   if (STRINGP (it->string))
  6449     {
  6450       unsigned char *s;
  6451 
  6452       pos = IT_STRING_CHARPOS (*it);
  6453       pos_byte = IT_STRING_BYTEPOS (*it);
  6454       string = it->string;
  6455       s = SDATA (string) + pos_byte;
  6456       if (STRING_MULTIBYTE (string))
  6457         it->c = STRING_CHAR (s);
  6458       else
  6459         it->c = *s;
  6460     }
  6461   else
  6462     {
  6463       pos = IT_CHARPOS (*it);
  6464       pos_byte = IT_BYTEPOS (*it);
  6465       string = Qnil;
  6466       it->c = FETCH_CHAR (pos_byte);
  6467     }
  6468 
  6469   /* If there's a valid composition and point is not inside of the
  6470      composition (in the case that the composition is from the current
  6471      buffer), draw a glyph composed from the composition components.  */
  6472   if (find_composition (pos, -1, &start, &end, &prop, string)
  6473       && composition_valid_p (start, end, prop)
  6474       && (STRINGP (it->string) || (PT <= start || PT >= end)))
  6475     {
  6476       if (start < pos)
  6477         /* As we can't handle this situation (perhaps font-lock added
  6478            a new composition), we just return here hoping that next
  6479            redisplay will detect this composition much earlier.  */
  6480         return HANDLED_NORMALLY;
  6481       if (start != pos)
  6482         {
  6483           if (STRINGP (it->string))
  6484             pos_byte = string_char_to_byte (it->string, start);
  6485           else
  6486             pos_byte = CHAR_TO_BYTE (start);
  6487         }
  6488       it->cmp_it.id = get_composition_id (start, pos_byte, end - start,
  6489                                                prop, string);
  6490 
  6491       if (it->cmp_it.id >= 0)
  6492         {
  6493           it->cmp_it.ch = -1;
  6494           it->cmp_it.nchars = COMPOSITION_LENGTH (prop);
  6495           it->cmp_it.nglyphs = -1;
  6496         }
  6497     }
  6498 
  6499   return HANDLED_NORMALLY;
  6500 }
  6501 
  6502 
  6503 
  6504 /***********************************************************************
  6505                            Overlay strings
  6506  ***********************************************************************/
  6507 
  6508 /* The following structure is used to record overlay strings for
  6509    later sorting in load_overlay_strings.  */
  6510 
  6511 struct overlay_entry
  6512 {
  6513   Lisp_Object overlay;
  6514   Lisp_Object string;
  6515   EMACS_INT priority;
  6516   bool after_string_p;
  6517 };
  6518 
  6519 
  6520 /* Set up iterator IT from overlay strings at its current position.
  6521    Called from handle_stop.  */
  6522 
  6523 static enum prop_handled
  6524 handle_overlay_change (struct it *it)
  6525 {
  6526   if (!STRINGP (it->string) && get_overlay_strings (it, 0))
  6527     return HANDLED_RECOMPUTE_PROPS;
  6528   else
  6529     return HANDLED_NORMALLY;
  6530 }
  6531 
  6532 
  6533 /* Set up the next overlay string for delivery by IT, if there is an
  6534    overlay string to deliver.  Called by set_iterator_to_next when the
  6535    end of the current overlay string is reached.  If there are more
  6536    overlay strings to display, IT->string and
  6537    IT->current.overlay_string_index are set appropriately here.
  6538    Otherwise IT->string is set to nil.  */
  6539 
  6540 static void
  6541 next_overlay_string (struct it *it)
  6542 {
  6543   ++it->current.overlay_string_index;
  6544   if (it->current.overlay_string_index == it->n_overlay_strings)
  6545     {
  6546       /* No more overlay strings.  Restore IT's settings to what
  6547          they were before overlay strings were processed, and
  6548          continue to deliver from current_buffer.  */
  6549 
  6550       it->ellipsis_p = it->stack[it->sp - 1].display_ellipsis_p;
  6551       pop_it (it);
  6552       eassert (it->sp > 0
  6553                || (NILP (it->string)
  6554                    && it->method == GET_FROM_BUFFER
  6555                    && it->stop_charpos >= BEGV
  6556                    && it->stop_charpos <= it->end_charpos));
  6557       it->current.overlay_string_index = -1;
  6558       it->n_overlay_strings = 0;
  6559       /* If there's an empty display string on the stack, pop the
  6560          stack, to resync the bidi iterator with IT's position.  Such
  6561          empty strings are pushed onto the stack in
  6562          get_overlay_strings_1.  */
  6563       if (it->sp > 0 && STRINGP (it->string) && !SCHARS (it->string))
  6564         pop_it (it);
  6565 
  6566       /* Since we've exhausted overlay strings at this buffer
  6567          position, set the flag to ignore overlays until we move to
  6568          another position.  (The flag will be reset in
  6569          next_element_from_buffer.)  But don't do that if the overlay
  6570          strings were loaded at position other than the current one,
  6571          which could happen if we called pop_it above, or if the
  6572          overlay strings were loaded by handle_invisible_prop at the
  6573          beginning of invisible text.  */
  6574       if (it->overlay_strings_charpos == IT_CHARPOS (*it))
  6575         it->ignore_overlay_strings_at_pos_p = true;
  6576 
  6577       /* If we're at the end of the buffer, record that we have
  6578          processed the overlay strings there already, so that
  6579          next_element_from_buffer doesn't try it again.  */
  6580       if (NILP (it->string)
  6581           && IT_CHARPOS (*it) >= it->end_charpos
  6582           && it->overlay_strings_charpos >= it->end_charpos)
  6583         it->overlay_strings_at_end_processed_p = true;
  6584       /* Note: we reset overlay_strings_charpos only here, to make
  6585          sure the just-processed overlays were indeed at EOB.
  6586          Otherwise, overlays on text with invisible text property,
  6587          which are processed with IT's position past the invisible
  6588          text, might fool us into thinking the overlays at EOB were
  6589          already processed (linum-mode can cause this, for
  6590          example).  */
  6591       it->overlay_strings_charpos = -1;
  6592     }
  6593   else
  6594     {
  6595       /* There are more overlay strings to process.  If
  6596          IT->current.overlay_string_index has advanced to a position
  6597          where we must load IT->overlay_strings with more strings, do
  6598          it.  We must load at the IT->overlay_strings_charpos where
  6599          IT->n_overlay_strings was originally computed; when invisible
  6600          text is present, this might not be IT_CHARPOS (Bug#7016).  */
  6601       int i = it->current.overlay_string_index % OVERLAY_STRING_CHUNK_SIZE;
  6602 
  6603       if (it->current.overlay_string_index && i == 0)
  6604         load_overlay_strings (it, it->overlay_strings_charpos);
  6605 
  6606       /* Initialize IT to deliver display elements from the overlay
  6607          string.  */
  6608       it->string = it->overlay_strings[i];
  6609       it->multibyte_p = STRING_MULTIBYTE (it->string);
  6610       SET_TEXT_POS (it->current.string_pos, 0, 0);
  6611       it->method = GET_FROM_STRING;
  6612       it->stop_charpos = 0;
  6613       it->end_charpos = SCHARS (it->string);
  6614       if (it->cmp_it.stop_pos >= 0)
  6615         it->cmp_it.stop_pos = 0;
  6616       it->prev_stop = 0;
  6617       it->base_level_stop = 0;
  6618 
  6619       /* Set up the bidi iterator for this overlay string.  */
  6620       if (it->bidi_p)
  6621         {
  6622           it->bidi_it.string.lstring = it->string;
  6623           it->bidi_it.string.s = NULL;
  6624           it->bidi_it.string.schars = SCHARS (it->string);
  6625           it->bidi_it.string.bufpos = it->overlay_strings_charpos;
  6626           it->bidi_it.string.from_disp_str = it->string_from_display_prop_p;
  6627           it->bidi_it.string.unibyte = !it->multibyte_p;
  6628           it->bidi_it.w = it->w;
  6629           bidi_init_it (0, 0, FRAME_WINDOW_P (it->f), &it->bidi_it);
  6630         }
  6631     }
  6632 
  6633   CHECK_IT (it);
  6634 }
  6635 
  6636 
  6637 /* Compare two overlay_entry structures E1 and E2.  Used as a
  6638    comparison function for qsort in load_overlay_strings.  Overlay
  6639    strings for the same position are sorted so that
  6640 
  6641    1. All after-strings come in front of before-strings, except
  6642    when they come from the same overlay.
  6643 
  6644    2. Within after-strings, strings are sorted so that overlay strings
  6645    from overlays with higher priorities come first.
  6646 
  6647    2. Within before-strings, strings are sorted so that overlay
  6648    strings from overlays with higher priorities come last.
  6649 
  6650    Value is analogous to strcmp.  */
  6651 
  6652 
  6653 static int
  6654 compare_overlay_entries (const void *e1, const void *e2)
  6655 {
  6656   struct overlay_entry const *entry1 = e1;
  6657   struct overlay_entry const *entry2 = e2;
  6658   int result;
  6659 
  6660   if (entry1->after_string_p != entry2->after_string_p)
  6661     {
  6662       /* Let after-strings appear in front of before-strings if
  6663          they come from different overlays.  */
  6664       if (EQ (entry1->overlay, entry2->overlay))
  6665         result = entry1->after_string_p ? 1 : -1;
  6666       else
  6667         result = entry1->after_string_p ? -1 : 1;
  6668     }
  6669   else if (entry1->priority != entry2->priority)
  6670     {
  6671       if (entry1->after_string_p)
  6672         /* After-strings sorted in order of decreasing priority.  */
  6673         result = entry2->priority < entry1->priority ? -1 : 1;
  6674       else
  6675         /* Before-strings sorted in order of increasing priority.  */
  6676         result = entry1->priority < entry2->priority ? -1 : 1;
  6677     }
  6678   else
  6679     result = 0;
  6680 
  6681   return result;
  6682 }
  6683 
  6684 
  6685 /* Load the vector IT->overlay_strings with overlay strings from IT's
  6686    current buffer position, or from CHARPOS if that is > 0.  Set
  6687    IT->n_overlays to the total number of overlay strings found.
  6688 
  6689    Overlay strings are processed OVERLAY_STRING_CHUNK_SIZE strings at
  6690    a time.  On entry into load_overlay_strings,
  6691    IT->current.overlay_string_index gives the number of overlay
  6692    strings that have already been loaded by previous calls to this
  6693    function.
  6694 
  6695    IT->add_overlay_start contains an additional overlay start
  6696    position to consider for taking overlay strings from, if non-zero.
  6697    This position comes into play when the overlay has an `invisible'
  6698    property, and both before and after-strings.  When we've skipped to
  6699    the end of the overlay, because of its `invisible' property, we
  6700    nevertheless want its before-string to appear.
  6701    IT->add_overlay_start will contain the overlay start position
  6702    in this case.
  6703 
  6704    Overlay strings are sorted so that after-string strings come in
  6705    front of before-string strings.  Within before and after-strings,
  6706    strings are sorted by overlay priority.  See also function
  6707    compare_overlay_entries.  */
  6708 
  6709 static void
  6710 load_overlay_strings (struct it *it, ptrdiff_t charpos)
  6711 {
  6712   ptrdiff_t n = 0;
  6713   struct overlay_entry entriesbuf[20];
  6714   ptrdiff_t size = ARRAYELTS (entriesbuf);
  6715   struct overlay_entry *entries = entriesbuf;
  6716   struct itree_node *node;
  6717 
  6718   USE_SAFE_ALLOCA;
  6719 
  6720   if (charpos <= 0)
  6721     charpos = IT_CHARPOS (*it);
  6722 
  6723   /* Append the overlay string STRING of overlay OVERLAY to vector
  6724      `entries' which has size `size' and currently contains `n'
  6725      elements.  AFTER_P means STRING is an after-string of
  6726      OVERLAY.  */
  6727 #define RECORD_OVERLAY_STRING(OVERLAY, STRING, AFTER_P)                 \
  6728   do                                                                    \
  6729     {                                                                   \
  6730       Lisp_Object priority;                                             \
  6731                                                                         \
  6732       if (n == size)                                                    \
  6733         {                                                               \
  6734           struct overlay_entry *old = entries;                          \
  6735           SAFE_NALLOCA (entries, 2, size);                              \
  6736           memcpy (entries, old, size * sizeof *entries);                \
  6737           size *= 2;                                                    \
  6738         }                                                               \
  6739                                                                         \
  6740       entries[n].string = (STRING);                                     \
  6741       entries[n].overlay = (OVERLAY);                                   \
  6742       priority = Foverlay_get ((OVERLAY), Qpriority);                   \
  6743       entries[n].priority = FIXNUMP (priority) ? XFIXNUM (priority) : 0;  \
  6744       entries[n].after_string_p = (AFTER_P);                            \
  6745       ++n;                                                              \
  6746     }                                                                   \
  6747   while (false)
  6748 
  6749 
  6750   /* Process overlays.  */
  6751   ITREE_FOREACH (node, current_buffer->overlays, charpos - 1, charpos + 1, DESCENDING)
  6752     {
  6753       Lisp_Object overlay = node->data;
  6754       eassert (OVERLAYP (overlay));
  6755       ptrdiff_t start = node->begin;
  6756       ptrdiff_t end = node->end;
  6757 
  6758       /* Skip this overlay if it doesn't start or end at IT's current
  6759          position.  */
  6760       if (end != charpos && start != charpos)
  6761         continue;
  6762 
  6763       /* Skip this overlay if it doesn't apply to IT->w.  */
  6764       Lisp_Object window = Foverlay_get (overlay, Qwindow);
  6765       if (WINDOWP (window) && XWINDOW (window) != it->w)
  6766         continue;
  6767 
  6768       /* If the text ``under'' the overlay is invisible, both before-
  6769          and after-strings from this overlay are visible; start and
  6770          end position are indistinguishable.  */
  6771       Lisp_Object invisible = Foverlay_get (overlay, Qinvisible);
  6772       int invis = TEXT_PROP_MEANS_INVISIBLE (invisible);
  6773 
  6774       /* If overlay has a non-empty before-string, record it.  */
  6775       Lisp_Object str;
  6776       if ((start == charpos || (end == charpos && invis != 0))
  6777           && (str = Foverlay_get (overlay, Qbefore_string), STRINGP (str))
  6778           && SCHARS (str))
  6779         RECORD_OVERLAY_STRING (overlay, str, false);
  6780 
  6781       /* If overlay has a non-empty after-string, record it.  */
  6782       if ((end == charpos || (start == charpos && invis != 0))
  6783           && (str = Foverlay_get (overlay, Qafter_string), STRINGP (str))
  6784           && SCHARS (str))
  6785         RECORD_OVERLAY_STRING (overlay, str, true);
  6786     }
  6787 
  6788 #undef RECORD_OVERLAY_STRING
  6789 
  6790   /* Sort entries.  */
  6791   if (n > 1)
  6792     qsort (entries, n, sizeof *entries, compare_overlay_entries);
  6793 
  6794   /* Record number of overlay strings, and where we computed it.  */
  6795   it->n_overlay_strings = n;
  6796   it->overlay_strings_charpos = charpos;
  6797 
  6798   /* IT->current.overlay_string_index is the number of overlay strings
  6799      that have already been consumed by IT.  Copy some of the
  6800      remaining overlay strings to IT->overlay_strings.  */
  6801   ptrdiff_t j = it->current.overlay_string_index;
  6802   for (ptrdiff_t i = 0; i < OVERLAY_STRING_CHUNK_SIZE && j < n; i++, j++)
  6803     {
  6804       it->overlay_strings[i] = entries[j].string;
  6805       it->string_overlays[i] = entries[j].overlay;
  6806     }
  6807 
  6808   CHECK_IT (it);
  6809   SAFE_FREE ();
  6810 }
  6811 
  6812 
  6813 /* Get the first chunk of overlay strings at IT's current buffer
  6814    position, or at CHARPOS if that is > 0.  Value is true if at
  6815    least one overlay string was found.  */
  6816 
  6817 static bool
  6818 get_overlay_strings_1 (struct it *it, ptrdiff_t charpos, bool compute_stop_p)
  6819 {
  6820   /* Get the first OVERLAY_STRING_CHUNK_SIZE overlay strings to
  6821      process.  This fills IT->overlay_strings with strings, and sets
  6822      IT->n_overlay_strings to the total number of strings to process.
  6823      IT->pos.overlay_string_index has to be set temporarily to zero
  6824      because load_overlay_strings needs this; it must be set to -1
  6825      when no overlay strings are found because a zero value would
  6826      indicate a position in the first overlay string.  */
  6827   it->current.overlay_string_index = 0;
  6828   load_overlay_strings (it, charpos);
  6829 
  6830   /* If we found overlay strings, set up IT to deliver display
  6831      elements from the first one.  Otherwise set up IT to deliver
  6832      from current_buffer.  */
  6833   if (it->n_overlay_strings)
  6834     {
  6835       /* Make sure we know settings in current_buffer, so that we can
  6836          restore meaningful values when we're done with the overlay
  6837          strings.  */
  6838       if (compute_stop_p)
  6839         compute_stop_pos (it);
  6840       eassert (it->face_id >= 0);
  6841 
  6842       /* Save IT's settings.  They are restored after all overlay
  6843          strings have been processed.  */
  6844       eassert (!compute_stop_p || it->sp == 0);
  6845 
  6846       /* When called from handle_stop, there might be an empty display
  6847          string loaded.  In that case, don't bother saving it.  But
  6848          don't use this optimization with the bidi iterator, since we
  6849          need the corresponding pop_it call to resync the bidi
  6850          iterator's position with IT's position, after we are done
  6851          with the overlay strings.  (The corresponding call to pop_it
  6852          in case of an empty display string is in
  6853          next_overlay_string.)  */
  6854       if (!(!it->bidi_p
  6855             && STRINGP (it->string) && !SCHARS (it->string)))
  6856         push_it (it, NULL);
  6857 
  6858       /* Set up IT to deliver display elements from the first overlay
  6859          string.  */
  6860       IT_STRING_CHARPOS (*it) = IT_STRING_BYTEPOS (*it) = 0;
  6861       it->string = it->overlay_strings[0];
  6862       it->from_overlay = Qnil;
  6863       it->stop_charpos = 0;
  6864       eassert (STRINGP (it->string));
  6865       it->end_charpos = SCHARS (it->string);
  6866       it->prev_stop = 0;
  6867       it->base_level_stop = 0;
  6868       it->multibyte_p = STRING_MULTIBYTE (it->string);
  6869       it->method = GET_FROM_STRING;
  6870       it->from_disp_prop_p = 0;
  6871       it->cmp_it.id = -1;
  6872 
  6873       /* Force paragraph direction to be that of the parent
  6874          buffer.  */
  6875       if (it->bidi_p && it->bidi_it.paragraph_dir == R2L)
  6876         it->paragraph_embedding = it->bidi_it.paragraph_dir;
  6877       else
  6878         it->paragraph_embedding = L2R;
  6879 
  6880       /* Set up the bidi iterator for this overlay string.  */
  6881       if (it->bidi_p)
  6882         {
  6883           ptrdiff_t pos = (charpos > 0 ? charpos : IT_CHARPOS (*it));
  6884 
  6885           it->bidi_it.string.lstring = it->string;
  6886           it->bidi_it.string.s = NULL;
  6887           it->bidi_it.string.schars = SCHARS (it->string);
  6888           it->bidi_it.string.bufpos = pos;
  6889           it->bidi_it.string.from_disp_str = it->string_from_display_prop_p;
  6890           it->bidi_it.string.unibyte = !it->multibyte_p;
  6891           it->bidi_it.w = it->w;
  6892           bidi_init_it (0, 0, FRAME_WINDOW_P (it->f), &it->bidi_it);
  6893         }
  6894       return true;
  6895     }
  6896 
  6897   it->current.overlay_string_index = -1;
  6898   return false;
  6899 }
  6900 
  6901 static bool
  6902 get_overlay_strings (struct it *it, ptrdiff_t charpos)
  6903 {
  6904   it->string = Qnil;
  6905   it->method = GET_FROM_BUFFER;
  6906 
  6907   get_overlay_strings_1 (it, charpos, true);
  6908 
  6909   CHECK_IT (it);
  6910 
  6911   /* Value is true if we found at least one overlay string.  */
  6912   return STRINGP (it->string);
  6913 }
  6914 
  6915 
  6916 
  6917 /***********************************************************************
  6918                       Saving and restoring state
  6919  ***********************************************************************/
  6920 
  6921 /* Save current settings of IT on IT->stack.  Called, for example,
  6922    before setting up IT for an overlay string, to be able to restore
  6923    IT's settings to what they were after the overlay string has been
  6924    processed.  If POSITION is non-NULL, it is the position to save on
  6925    the stack instead of IT->position.  */
  6926 
  6927 static void
  6928 push_it (struct it *it, struct text_pos *position)
  6929 {
  6930   struct iterator_stack_entry *p;
  6931 
  6932   eassert (it->sp < IT_STACK_SIZE);
  6933   p = it->stack + it->sp;
  6934 
  6935   p->stop_charpos = it->stop_charpos;
  6936   p->prev_stop = it->prev_stop;
  6937   p->base_level_stop = it->base_level_stop;
  6938   p->cmp_it = it->cmp_it;
  6939   eassert (it->face_id >= 0);
  6940   p->face_id = it->face_id;
  6941   p->string = it->string;
  6942   p->method = it->method;
  6943   p->from_overlay = it->from_overlay;
  6944   switch (p->method)
  6945     {
  6946     case GET_FROM_IMAGE:
  6947       p->u.image.object = it->object;
  6948       p->u.image.image_id = it->image_id;
  6949       p->u.image.slice = it->slice;
  6950       break;
  6951     case GET_FROM_STRETCH:
  6952       p->u.stretch.object = it->object;
  6953       break;
  6954     case GET_FROM_XWIDGET:
  6955       p->u.xwidget.object = it->object;
  6956       break;
  6957     case GET_FROM_BUFFER:
  6958     case GET_FROM_DISPLAY_VECTOR:
  6959     case GET_FROM_STRING:
  6960     case GET_FROM_C_STRING:
  6961       break;
  6962     default:
  6963       emacs_abort ();
  6964     }
  6965   p->position = position ? *position : it->position;
  6966   p->current = it->current;
  6967   p->end_charpos = it->end_charpos;
  6968   p->string_nchars = it->string_nchars;
  6969   p->area = it->area;
  6970   p->multibyte_p = it->multibyte_p;
  6971   p->avoid_cursor_p = it->avoid_cursor_p;
  6972   p->space_width = it->space_width;
  6973   p->font_height = it->font_height;
  6974   p->voffset = it->voffset;
  6975   p->string_from_display_prop_p = it->string_from_display_prop_p;
  6976   p->string_from_prefix_prop_p = it->string_from_prefix_prop_p;
  6977   p->display_ellipsis_p = false;
  6978   p->line_wrap = it->line_wrap;
  6979   p->bidi_p = it->bidi_p;
  6980   p->paragraph_embedding = it->paragraph_embedding;
  6981   p->from_disp_prop_p = it->from_disp_prop_p;
  6982   ++it->sp;
  6983 
  6984   /* Save the state of the bidi iterator as well. */
  6985   if (it->bidi_p)
  6986     bidi_push_it (&it->bidi_it);
  6987 }
  6988 
  6989 static void
  6990 iterate_out_of_display_property (struct it *it)
  6991 {
  6992   bool buffer_p = !STRINGP (it->string);
  6993   ptrdiff_t eob = (buffer_p ? ZV : it->end_charpos);
  6994   ptrdiff_t bob = (buffer_p ? BEGV : 0);
  6995 
  6996   eassert (eob >= CHARPOS (it->position) && CHARPOS (it->position) >= bob);
  6997 
  6998   /* Maybe initialize paragraph direction.  If we are at the beginning
  6999      of a new paragraph, next_element_from_buffer may not have a
  7000      chance to do that.  */
  7001   if (it->bidi_it.first_elt && it->bidi_it.charpos < eob)
  7002     bidi_paragraph_init (it->paragraph_embedding, &it->bidi_it, true);
  7003   /* prev_stop can be zero, so check against BEGV as well.  */
  7004   while (it->bidi_it.charpos >= bob
  7005          && it->prev_stop <= it->bidi_it.charpos
  7006          && it->bidi_it.charpos < CHARPOS (it->position)
  7007          && it->bidi_it.charpos < eob)
  7008     bidi_move_to_visually_next (&it->bidi_it);
  7009   /* Record the stop_pos we just crossed, for when we cross it
  7010      back, maybe.  */
  7011   if (it->bidi_it.charpos > CHARPOS (it->position))
  7012     it->prev_stop = CHARPOS (it->position);
  7013   /* If we ended up not where pop_it put us, resync IT's
  7014      positional members with the bidi iterator. */
  7015   if (it->bidi_it.charpos != CHARPOS (it->position))
  7016     SET_TEXT_POS (it->position, it->bidi_it.charpos, it->bidi_it.bytepos);
  7017   if (buffer_p)
  7018     it->current.pos = it->position;
  7019   else
  7020     it->current.string_pos = it->position;
  7021 }
  7022 
  7023 /* Restore the IT->face_box_p flag, since it could have been
  7024    overwritten by the face of the object that we just finished
  7025    displaying.  Also, set the IT->start_of_box_run_p flag if the
  7026    change in faces requires that.  */
  7027 static void
  7028 restore_face_box_flags (struct it *it, int prev_face_id)
  7029 {
  7030   struct face *face = FACE_FROM_ID_OR_NULL (it->f, it->face_id);
  7031 
  7032   if (face)
  7033     {
  7034       struct face *prev_face = FACE_FROM_ID_OR_NULL (it->f, prev_face_id);
  7035 
  7036       if (!(it->start_of_box_run_p && prev_face && prev_face->box))
  7037         it->start_of_box_run_p = (face->box != FACE_NO_BOX
  7038                                   && (prev_face == NULL
  7039                                       || prev_face->box == FACE_NO_BOX));
  7040       it->face_box_p = face->box != FACE_NO_BOX;
  7041     }
  7042 }
  7043 
  7044 /* Restore IT's settings from IT->stack.  Called, for example, when no
  7045    more overlay strings must be processed, and we return to delivering
  7046    display elements from a buffer, or when the end of a string from a
  7047    `display' property is reached and we return to delivering display
  7048    elements from an overlay string, or from a buffer.  */
  7049 
  7050 static void
  7051 pop_it (struct it *it)
  7052 {
  7053   struct iterator_stack_entry *p;
  7054   bool from_display_prop = it->from_disp_prop_p;
  7055   ptrdiff_t prev_pos = IT_CHARPOS (*it);
  7056   int prev_face_id = it->face_id;
  7057 
  7058   eassert (it->sp > 0);
  7059   --it->sp;
  7060   p = it->stack + it->sp;
  7061   it->stop_charpos = p->stop_charpos;
  7062   it->prev_stop = p->prev_stop;
  7063   it->base_level_stop = p->base_level_stop;
  7064   it->cmp_it = p->cmp_it;
  7065   it->face_id = p->face_id;
  7066   it->current = p->current;
  7067   it->position = p->position;
  7068   it->string = p->string;
  7069   it->from_overlay = p->from_overlay;
  7070   if (NILP (it->string))
  7071     SET_TEXT_POS (it->current.string_pos, -1, -1);
  7072   it->method = p->method;
  7073   switch (it->method)
  7074     {
  7075     case GET_FROM_IMAGE:
  7076       it->image_id = p->u.image.image_id;
  7077       it->object = p->u.image.object;
  7078       it->slice = p->u.image.slice;
  7079       break;
  7080     case GET_FROM_XWIDGET:
  7081       it->object = p->u.xwidget.object;
  7082       break;
  7083     case GET_FROM_STRETCH:
  7084       it->object = p->u.stretch.object;
  7085       break;
  7086     case GET_FROM_BUFFER:
  7087       {
  7088         restore_face_box_flags (it, prev_face_id);
  7089         it->object = it->w->contents;
  7090       }
  7091       break;
  7092     case GET_FROM_STRING:
  7093       {
  7094         restore_face_box_flags (it, prev_face_id);
  7095         it->object = it->string;
  7096       }
  7097       break;
  7098     case GET_FROM_DISPLAY_VECTOR:
  7099       if (it->s)
  7100         it->method = GET_FROM_C_STRING;
  7101       else if (STRINGP (it->string))
  7102         it->method = GET_FROM_STRING;
  7103       else
  7104         {
  7105           it->method = GET_FROM_BUFFER;
  7106           it->object = it->w->contents;
  7107         }
  7108       break;
  7109     case GET_FROM_C_STRING:
  7110       break;
  7111     default:
  7112       emacs_abort ();
  7113     }
  7114   it->end_charpos = p->end_charpos;
  7115   it->string_nchars = p->string_nchars;
  7116   it->area = p->area;
  7117   it->multibyte_p = p->multibyte_p;
  7118   it->avoid_cursor_p = p->avoid_cursor_p;
  7119   it->space_width = p->space_width;
  7120   it->font_height = p->font_height;
  7121   it->voffset = p->voffset;
  7122   it->string_from_display_prop_p = p->string_from_display_prop_p;
  7123   it->string_from_prefix_prop_p = p->string_from_prefix_prop_p;
  7124   it->line_wrap = p->line_wrap;
  7125   it->bidi_p = p->bidi_p;
  7126   it->paragraph_embedding = p->paragraph_embedding;
  7127   it->from_disp_prop_p = p->from_disp_prop_p;
  7128   if (it->bidi_p)
  7129     {
  7130       bidi_pop_it (&it->bidi_it);
  7131       /* Bidi-iterate until we get out of the portion of text, if any,
  7132          covered by a `display' text property or by an overlay with
  7133          `display' property.  (We cannot just jump there, because the
  7134          internal coherency of the bidi iterator state can not be
  7135          preserved across such jumps.)  We also must determine the
  7136          paragraph base direction if the overlay we just processed is
  7137          at the beginning of a new paragraph.  */
  7138       if (from_display_prop
  7139           && (it->method == GET_FROM_BUFFER || it->method == GET_FROM_STRING))
  7140         iterate_out_of_display_property (it);
  7141 
  7142       eassert ((BUFFERP (it->object)
  7143                 && IT_CHARPOS (*it) == it->bidi_it.charpos
  7144                 && IT_BYTEPOS (*it) == it->bidi_it.bytepos)
  7145                || (STRINGP (it->object)
  7146                    && IT_STRING_CHARPOS (*it) == it->bidi_it.charpos
  7147                    && IT_STRING_BYTEPOS (*it) == it->bidi_it.bytepos)
  7148                || (CONSP (it->object) && it->method == GET_FROM_STRETCH)
  7149                /* We could be in the middle of handling a list or a
  7150                   vector of several 'display' properties, in which
  7151                   case we should only verify the above conditions when
  7152                   we pop the iterator stack the last time, because
  7153                   higher stack levels cannot "iterate out of the
  7154                   display property".  */
  7155                || it->sp > 0);
  7156     }
  7157   /* If we move the iterator over text covered by a display property
  7158      to a new buffer position, any info about previously seen overlays
  7159      is no longer valid.  */
  7160   if (from_display_prop && it->sp == 0 && CHARPOS (it->position) != prev_pos)
  7161     it->ignore_overlay_strings_at_pos_p = false;
  7162 }
  7163 
  7164 
  7165 
  7166 /***********************************************************************
  7167                           Moving over lines
  7168  ***********************************************************************/
  7169 
  7170 /* Set IT's current position to the previous line start.  */
  7171 
  7172 static void
  7173 back_to_previous_line_start (struct it *it)
  7174 {
  7175   ptrdiff_t cp = IT_CHARPOS (*it), bp = IT_BYTEPOS (*it);
  7176 
  7177   dec_both (&cp, &bp);
  7178   SET_WITH_NARROWED_BEGV (it, IT_CHARPOS (*it),
  7179                           find_newline_no_quit (cp, bp, -1, &IT_BYTEPOS (*it)),
  7180                           get_small_narrowing_begv (it->w, IT_CHARPOS (*it)));
  7181 }
  7182 
  7183 /* Find in the current buffer the first display or overlay string
  7184    between STARTPOS and ENDPOS that includes embedded newlines.
  7185    Consider only overlays that apply to window W.
  7186    Value is non-zero if such a display/overlay string is found.  */
  7187 static bool
  7188 strings_with_newlines (ptrdiff_t startpos, ptrdiff_t endpos, struct window *w)
  7189 {
  7190   struct itree_node *node;
  7191   /* Process overlays.  */
  7192   ITREE_FOREACH (node, current_buffer->overlays, startpos, endpos, DESCENDING)
  7193     {
  7194       Lisp_Object overlay = node->data;
  7195       eassert (OVERLAYP (overlay));
  7196 
  7197       /* Skip this overlay if it doesn't apply to our window.  */
  7198       Lisp_Object window = Foverlay_get (overlay, Qwindow);
  7199       if (WINDOWP (window) && XWINDOW (window) != w)
  7200         continue;
  7201 
  7202       ptrdiff_t ostart = node->begin;
  7203       ptrdiff_t oend = node->end;
  7204 
  7205       /* Skip overlays that don't overlap the range.  */
  7206       if (!((startpos < oend && ostart < endpos)
  7207             || (ostart == oend
  7208                 && (startpos == oend || (endpos == ZV && oend == endpos)))))
  7209         continue;
  7210 
  7211       Lisp_Object str;
  7212       str = Foverlay_get (overlay, Qbefore_string);
  7213       if (STRINGP (str) && SCHARS (str)
  7214           && memchr (SDATA (str), '\n', SBYTES (str)))
  7215         return true;
  7216       str = Foverlay_get (overlay, Qafter_string);
  7217       if (STRINGP (str) && SCHARS (str)
  7218           && memchr (SDATA (str), '\n', SBYTES (str)))
  7219         return true;
  7220     }
  7221 
  7222   /* Check for 'display' properties whose values include strings.  */
  7223   Lisp_Object cpos = make_fixnum (startpos);
  7224   Lisp_Object limpos = make_fixnum (endpos);
  7225 
  7226   while ((cpos = Fnext_single_property_change (cpos, Qdisplay, Qnil, limpos),
  7227           !(NILP (cpos) || XFIXNAT (cpos) >= endpos)))
  7228     {
  7229       Lisp_Object spec = Fget_char_property (cpos, Qdisplay, Qnil);
  7230       Lisp_Object string = string_from_display_spec (spec);
  7231       if (STRINGP (string)
  7232           && memchr (SDATA (string), '\n', SBYTES (string)))
  7233         return true;
  7234     }
  7235 
  7236   return false;
  7237 }
  7238 
  7239 
  7240 /* Move IT to the next line start.
  7241 
  7242    Value is true if a newline was found.  Set *SKIPPED_P to true if
  7243    we skipped over part of the text (as opposed to moving the iterator
  7244    continuously over the text).  Otherwise, don't change the value
  7245    of *SKIPPED_P.
  7246 
  7247    If BIDI_IT_PREV is non-NULL, store into it the state of the bidi
  7248    iterator on the newline, if it was found.
  7249 
  7250    Newlines may come from buffer text, overlay strings, or strings
  7251    displayed via the `display' property.  That's the reason we can't
  7252    simply use find_newline_no_quit.
  7253 
  7254    Note that this function may not skip over invisible text that is so
  7255    because of text properties and immediately follows a newline.  If
  7256    it would, function reseat_at_next_visible_line_start, when called
  7257    from set_iterator_to_next, would effectively make invisible
  7258    characters following a newline part of the wrong glyph row, which
  7259    leads to wrong cursor motion.  */
  7260 
  7261 static bool
  7262 forward_to_next_line_start (struct it *it, bool *skipped_p,
  7263                             struct bidi_it *bidi_it_prev)
  7264 {
  7265   ptrdiff_t old_selective;
  7266   bool newline_found_p = false;
  7267   int n;
  7268   const int MAX_NEWLINE_DISTANCE = 500;
  7269 
  7270   /* If already on a newline, just consume it to avoid unintended
  7271      skipping over invisible text below.  */
  7272   if (it->what == IT_CHARACTER
  7273       && it->c == '\n'
  7274       && CHARPOS (it->position) == IT_CHARPOS (*it))
  7275     {
  7276       if (it->bidi_p && bidi_it_prev)
  7277         *bidi_it_prev = it->bidi_it;
  7278       set_iterator_to_next (it, false);
  7279       it->c = 0;
  7280       return true;
  7281     }
  7282 
  7283   /* Don't handle selective display in the following.  It's (a)
  7284      unnecessary because it's done by the caller, and (b) leads to an
  7285      infinite recursion because next_element_from_ellipsis indirectly
  7286      calls this function.  */
  7287   old_selective = it->selective;
  7288   it->selective = 0;
  7289 
  7290   /* Scan for a newline within MAX_NEWLINE_DISTANCE display elements
  7291      from buffer text, or till the end of the string if iterating a
  7292      string.  */
  7293   for (n = 0;
  7294        !newline_found_p && n < MAX_NEWLINE_DISTANCE;
  7295        n += !STRINGP (it->string))
  7296     {
  7297       if (!get_next_display_element (it))
  7298         return false;
  7299       newline_found_p = it->what == IT_CHARACTER && it->c == '\n';
  7300       if (newline_found_p && it->bidi_p && bidi_it_prev)
  7301         *bidi_it_prev = it->bidi_it;
  7302       set_iterator_to_next (it, false);
  7303     }
  7304 
  7305   /* If we didn't find a newline near enough, see if we can use a
  7306      short-cut.  */
  7307   if (!newline_found_p)
  7308     {
  7309       ptrdiff_t bytepos, start = IT_CHARPOS (*it);
  7310       ptrdiff_t limit = find_newline_no_quit (start, IT_BYTEPOS (*it),
  7311                                               1, &bytepos);
  7312       eassert (!STRINGP (it->string));
  7313 
  7314       /* it->stop_charpos >= limit means we already know there's no
  7315          stop position up until the newline at LIMIT, so there's no
  7316          need for any further checks.  */
  7317       bool no_strings_with_newlines = it->stop_charpos >= limit;
  7318 
  7319       if (!no_strings_with_newlines)
  7320         {
  7321           if (!(current_buffer->long_line_optimizations_p
  7322                 && it->line_wrap == TRUNCATE))
  7323             {
  7324               /* Quick-and-dirty check: if there isn't any `display'
  7325                  property in sight, and no overlays, we're done.  */
  7326               Lisp_Object pos =
  7327                 Fnext_single_property_change (make_fixnum (start),
  7328                                               Qdisplay, Qnil,
  7329                                               make_fixnum (limit));
  7330               no_strings_with_newlines =
  7331                 (NILP (pos) || XFIXNAT (pos) == limit) /* no 'display' props */
  7332                 && next_overlay_change (start) == ZV;  /* no overlays */
  7333             }
  7334           else
  7335             {
  7336               /* For buffers with very long and truncated lines we try
  7337                  harder, because it's worth our while to spend some
  7338                  time looking into the overlays and 'display' properties
  7339                  if we can then avoid iterating through all of them.  */
  7340               no_strings_with_newlines =
  7341                 !strings_with_newlines (start, limit, it->w);
  7342             }
  7343         }
  7344 
  7345       /* If there's no display or overlay strings with embedded
  7346          newlines until the position of the newline in buffer text, we
  7347          can just use that position.  */
  7348       if (no_strings_with_newlines)
  7349         {
  7350           if (!it->bidi_p || !bidi_it_prev)
  7351             {
  7352               /* The optimal case: just jump there.  */
  7353               IT_CHARPOS (*it) = limit;
  7354               IT_BYTEPOS (*it) = bytepos;
  7355             }
  7356           else
  7357             {
  7358               /* The less optimal case: need to bidi-walk there, but
  7359                  this is still cheaper that the full iteration using
  7360                  get_next_display_element and set_iterator_to_next.  */
  7361               struct bidi_it bprev;
  7362 
  7363               /* Help bidi.c avoid expensive searches for display
  7364                  properties and overlays, by telling it that there are
  7365                  none up to `limit'.  */
  7366               if (it->bidi_it.disp_pos < limit)
  7367                 {
  7368                   it->bidi_it.disp_pos = limit;
  7369                   it->bidi_it.disp_prop = 0;
  7370                 }
  7371               do {
  7372                 bprev = it->bidi_it;
  7373                 bidi_move_to_visually_next (&it->bidi_it);
  7374               } while (it->bidi_it.charpos != limit);
  7375               IT_CHARPOS (*it) = limit;
  7376               IT_BYTEPOS (*it) = it->bidi_it.bytepos;
  7377               if (bidi_it_prev)
  7378                 *bidi_it_prev = bprev;
  7379             }
  7380           *skipped_p = newline_found_p = true;
  7381         }
  7382       else
  7383         {
  7384           /* The slow case.  */
  7385           while (!newline_found_p)
  7386             {
  7387               if (!get_next_display_element (it))
  7388                 break;
  7389               newline_found_p = ITERATOR_AT_END_OF_LINE_P (it);
  7390               if (newline_found_p && it->bidi_p && bidi_it_prev)
  7391                 *bidi_it_prev = it->bidi_it;
  7392               set_iterator_to_next (it, false);
  7393             }
  7394         }
  7395     }
  7396 
  7397   it->selective = old_selective;
  7398   return newline_found_p;
  7399 }
  7400 
  7401 
  7402 /* Set IT's current position to the previous visible line start.  Skip
  7403    invisible text that is so either due to text properties or due to
  7404    selective display.  Caution: this does not change IT->current_x and
  7405    IT->hpos.  */
  7406 
  7407 static void
  7408 back_to_previous_visible_line_start (struct it *it)
  7409 {
  7410   while (IT_CHARPOS (*it) > BEGV)
  7411     {
  7412       back_to_previous_line_start (it);
  7413 
  7414       if (IT_CHARPOS (*it) <= BEGV)
  7415         break;
  7416 
  7417       /* If selective > 0, then lines indented more than its value are
  7418          invisible.  */
  7419       if (it->selective > 0
  7420           && indented_beyond_p (IT_CHARPOS (*it), IT_BYTEPOS (*it),
  7421                                 it->selective))
  7422         continue;
  7423 
  7424       /* Check the newline before point for invisibility.  */
  7425       {
  7426         Lisp_Object prop;
  7427         prop = Fget_char_property (make_fixnum (IT_CHARPOS (*it) - 1),
  7428                                    Qinvisible, it->window);
  7429         if (TEXT_PROP_MEANS_INVISIBLE (prop) != 0)
  7430           continue;
  7431       }
  7432 
  7433       if (IT_CHARPOS (*it) <= BEGV)
  7434         break;
  7435 
  7436       {
  7437         struct it it2;
  7438         void *it2data = NULL;
  7439         ptrdiff_t pos;
  7440         ptrdiff_t beg, end;
  7441         Lisp_Object val, overlay;
  7442 
  7443         SAVE_IT (it2, *it, it2data);
  7444 
  7445         /* If newline is part of a composition, continue from start of composition */
  7446         if (find_composition (IT_CHARPOS (*it), -1, &beg, &end, &val, Qnil)
  7447             && beg < IT_CHARPOS (*it))
  7448           goto replaced;
  7449 
  7450         /* If newline is replaced by a display property, find start of overlay
  7451            or interval and continue search from that point.  */
  7452         pos = --IT_CHARPOS (it2);
  7453         --IT_BYTEPOS (it2);
  7454         it2.sp = 0;
  7455         bidi_unshelve_cache (NULL, false);
  7456         it2.string_from_display_prop_p = false;
  7457         it2.from_disp_prop_p = false;
  7458         if (handle_display_prop (&it2) == HANDLED_RETURN
  7459             && !NILP (val = get_char_property_and_overlay
  7460                       (make_fixnum (pos), Qdisplay, Qnil, &overlay))
  7461             && (OVERLAYP (overlay)
  7462                 ? (beg = OVERLAY_START (overlay))
  7463                 : get_property_and_range (pos, Qdisplay, &val, &beg, &end, Qnil)))
  7464           {
  7465             RESTORE_IT (it, it, it2data);
  7466             goto replaced;
  7467           }
  7468 
  7469         /* Newline is not replaced by anything -- so we are done.  */
  7470         RESTORE_IT (it, it, it2data);
  7471         break;
  7472 
  7473       replaced:
  7474         if (beg < BEGV)
  7475           beg = BEGV;
  7476         IT_CHARPOS (*it) = beg;
  7477         IT_BYTEPOS (*it) = buf_charpos_to_bytepos (current_buffer, beg);
  7478       }
  7479     }
  7480 
  7481   it->continuation_lines_width = 0;
  7482 
  7483   eassert (IT_CHARPOS (*it) >= BEGV);
  7484   eassert (it->medium_narrowing_begv > 0 /* long-line optimizations: all bets off */
  7485            || IT_CHARPOS (*it) == BEGV
  7486            || FETCH_BYTE (IT_BYTEPOS (*it) - 1) == '\n');
  7487   CHECK_IT (it);
  7488 }
  7489 
  7490 
  7491 /* Reseat iterator IT at the previous visible line start.  Skip
  7492    invisible text that is so either due to text properties or due to
  7493    selective display.  At the end, update IT's overlay information,
  7494    face information etc.  */
  7495 
  7496 void
  7497 reseat_at_previous_visible_line_start (struct it *it)
  7498 {
  7499   back_to_previous_visible_line_start (it);
  7500   reseat (it, it->current.pos, true);
  7501   CHECK_IT (it);
  7502 }
  7503 
  7504 
  7505 /* Reseat iterator IT on the next visible line start in the current
  7506    buffer.  ON_NEWLINE_P means position IT on the newline
  7507    preceding the line start.  Skip over invisible text that is so
  7508    because of selective display.  Compute faces, overlays etc at the
  7509    new position.  Note that this function does not skip over text that
  7510    is invisible because of text properties.  */
  7511 
  7512 static void
  7513 reseat_at_next_visible_line_start (struct it *it, bool on_newline_p)
  7514 {
  7515   bool skipped_p = false;
  7516   struct bidi_it bidi_it_prev;
  7517   bool newline_found_p
  7518     = forward_to_next_line_start (it, &skipped_p,
  7519                                   on_newline_p ? &bidi_it_prev : NULL);
  7520 
  7521   /* Skip over lines that are invisible because they are indented
  7522      more than the value of IT->selective.  */
  7523   if (it->selective > 0)
  7524     while (IT_CHARPOS (*it) < ZV
  7525            && indented_beyond_p (IT_CHARPOS (*it), IT_BYTEPOS (*it),
  7526                                  it->selective))
  7527       {
  7528         eassert (IT_BYTEPOS (*it) == BEGV
  7529                  || FETCH_BYTE (IT_BYTEPOS (*it) - 1) == '\n');
  7530         newline_found_p =
  7531           forward_to_next_line_start (it, &skipped_p,
  7532                                       on_newline_p ? &bidi_it_prev : NULL);
  7533       }
  7534 
  7535   /* Position on the newline if that's what's requested.  */
  7536   if (on_newline_p && newline_found_p)
  7537     {
  7538       if (STRINGP (it->string))
  7539         {
  7540           if (IT_STRING_CHARPOS (*it) > 0)
  7541             {
  7542               if (!it->bidi_p)
  7543                 {
  7544                   --IT_STRING_CHARPOS (*it);
  7545                   --IT_STRING_BYTEPOS (*it);
  7546                 }
  7547               else
  7548                 {
  7549                   /* We need to restore the bidi iterator to the state
  7550                      it had on the newline, and resync the IT's
  7551                      position with that.  */
  7552                   it->bidi_it = bidi_it_prev;
  7553                   IT_STRING_CHARPOS (*it) = it->bidi_it.charpos;
  7554                   IT_STRING_BYTEPOS (*it) = it->bidi_it.bytepos;
  7555                 }
  7556             }
  7557         }
  7558       else if (IT_CHARPOS (*it) > BEGV)
  7559         {
  7560           if (!it->bidi_p)
  7561             {
  7562               --IT_CHARPOS (*it);
  7563               --IT_BYTEPOS (*it);
  7564             }
  7565           else
  7566             {
  7567               /* We need to restore the bidi iterator to the state it
  7568                  had on the newline and resync IT with that.  */
  7569               it->bidi_it = bidi_it_prev;
  7570               IT_CHARPOS (*it) = it->bidi_it.charpos;
  7571               IT_BYTEPOS (*it) = it->bidi_it.bytepos;
  7572             }
  7573           reseat (it, it->current.pos, false);
  7574         }
  7575     }
  7576   else if (skipped_p)
  7577     reseat (it, it->current.pos, false);
  7578 
  7579   CHECK_IT (it);
  7580 }
  7581 
  7582 
  7583 
  7584 /***********************************************************************
  7585                    Changing an iterator's position
  7586 ***********************************************************************/
  7587 
  7588 /* Change IT's current position to POS in current_buffer.
  7589    If FORCE_P, always check for text properties at the new position.
  7590    Otherwise, text properties are only looked up if POS >=
  7591    IT->check_charpos of a property.  */
  7592 
  7593 static void
  7594 reseat (struct it *it, struct text_pos pos, bool force_p)
  7595 {
  7596   ptrdiff_t original_pos = IT_CHARPOS (*it);
  7597 
  7598   reseat_1 (it, pos, false);
  7599 
  7600   if (current_buffer->long_line_optimizations_p)
  7601     {
  7602       if (!it->medium_narrowing_begv)
  7603         {
  7604           it->medium_narrowing_begv
  7605             = get_medium_narrowing_begv (it->w, window_point (it->w));
  7606           it->medium_narrowing_zv
  7607             = get_medium_narrowing_zv (it->w, window_point (it->w));
  7608           it->large_narrowing_begv
  7609             = get_large_narrowing_begv (window_point (it->w));
  7610           it->large_narrowing_zv
  7611             = get_large_narrowing_zv (window_point (it->w));
  7612         }
  7613       else if ((pos.charpos < it->medium_narrowing_begv
  7614                 || pos.charpos > it->medium_narrowing_zv)
  7615                 && (!redisplaying_p || it->line_wrap == TRUNCATE))
  7616         {
  7617           it->medium_narrowing_begv
  7618             = get_medium_narrowing_begv (it->w, pos.charpos);
  7619           it->medium_narrowing_zv
  7620             = get_medium_narrowing_zv (it->w, pos.charpos);
  7621           it->large_narrowing_begv
  7622             = get_large_narrowing_begv (window_point (it->w));
  7623           it->large_narrowing_zv
  7624             = get_large_narrowing_zv (window_point (it->w));
  7625         }
  7626     }
  7627 
  7628   /* Determine where to check text properties.  Avoid doing it
  7629      where possible because text property lookup is very expensive.  */
  7630   if (force_p
  7631       || CHARPOS (pos) > it->stop_charpos
  7632       || CHARPOS (pos) < original_pos)
  7633     {
  7634       if (it->bidi_p)
  7635         {
  7636           /* For bidi iteration, we need to prime prev_stop and
  7637              base_level_stop with our best estimations.  */
  7638           /* Implementation note: Of course, POS is not necessarily a
  7639              stop position, so assigning prev_pos to it is a lie; we
  7640              should have called compute_stop_backwards.  However, if
  7641              the current buffer does not include any R2L characters,
  7642              that call would be a waste of cycles, because the
  7643              iterator will never move back, and thus never cross this
  7644              "fake" stop position.  So we delay that backward search
  7645              until the time we really need it, in next_element_from_buffer.  */
  7646           if (CHARPOS (pos) != it->prev_stop)
  7647             it->prev_stop = CHARPOS (pos);
  7648           if (CHARPOS (pos) < it->base_level_stop)
  7649             it->base_level_stop = 0; /* meaning it's unknown */
  7650           handle_stop (it);
  7651         }
  7652       else
  7653         {
  7654           handle_stop (it);
  7655           it->prev_stop = it->base_level_stop = 0;
  7656         }
  7657 
  7658     }
  7659 
  7660   CHECK_IT (it);
  7661 }
  7662 
  7663 
  7664 /* Change IT's buffer position to POS.  SET_STOP_P means set
  7665    IT->stop_pos to POS, also.  */
  7666 
  7667 static void
  7668 reseat_1 (struct it *it, struct text_pos pos, bool set_stop_p)
  7669 {
  7670   /* Don't call this function when scanning a C string.  */
  7671   eassert (it->s == NULL);
  7672 
  7673   /* POS must be a reasonable value.  */
  7674   eassert (CHARPOS (pos) >= BEGV && CHARPOS (pos) <= ZV);
  7675 
  7676   it->current.pos = it->position = pos;
  7677   it->end_charpos = ZV;
  7678   it->dpvec = NULL;
  7679   it->current.dpvec_index = -1;
  7680   it->current.overlay_string_index = -1;
  7681   IT_STRING_CHARPOS (*it) = -1;
  7682   IT_STRING_BYTEPOS (*it) = -1;
  7683   it->string = Qnil;
  7684   it->method = GET_FROM_BUFFER;
  7685   it->object = it->w->contents;
  7686   it->area = TEXT_AREA;
  7687   it->multibyte_p = !NILP (BVAR (current_buffer, enable_multibyte_characters));
  7688   it->sp = 0;
  7689   it->string_from_display_prop_p = false;
  7690   it->string_from_prefix_prop_p = false;
  7691 
  7692   it->from_disp_prop_p = false;
  7693   it->face_before_selective_p = false;
  7694   if (it->bidi_p)
  7695     {
  7696       bidi_init_it (IT_CHARPOS (*it), IT_BYTEPOS (*it), FRAME_WINDOW_P (it->f),
  7697                     &it->bidi_it);
  7698       bidi_unshelve_cache (NULL, false);
  7699       it->bidi_it.paragraph_dir = NEUTRAL_DIR;
  7700       it->bidi_it.string.s = NULL;
  7701       it->bidi_it.string.lstring = Qnil;
  7702       it->bidi_it.string.bufpos = 0;
  7703       it->bidi_it.string.from_disp_str = false;
  7704       it->bidi_it.string.unibyte = false;
  7705       it->bidi_it.w = it->w;
  7706     }
  7707 
  7708   if (set_stop_p)
  7709     {
  7710       it->stop_charpos = CHARPOS (pos);
  7711       it->base_level_stop = CHARPOS (pos);
  7712     }
  7713   /* This make the information stored in it->cmp_it invalidate.  */
  7714   it->cmp_it.id = -1;
  7715   it->min_width_property = Qnil;
  7716 }
  7717 
  7718 
  7719 /* Set up IT for displaying a string, starting at CHARPOS in window W.
  7720    If S is non-null, it is a C string to iterate over.  Otherwise,
  7721    STRING gives a Lisp string to iterate over.
  7722 
  7723    If PRECISION > 0, don't return more then PRECISION number of
  7724    characters from the string.
  7725 
  7726    If FIELD_WIDTH > 0, return padding spaces until FIELD_WIDTH
  7727    characters have been returned.  FIELD_WIDTH < 0 means an infinite
  7728    field width.
  7729 
  7730    MULTIBYTE = 0 means disable processing of multibyte characters,
  7731    MULTIBYTE > 0 means enable it,
  7732    MULTIBYTE < 0 means use IT->multibyte_p.
  7733 
  7734    IT must be initialized via a prior call to init_iterator before
  7735    calling this function.  */
  7736 
  7737 static void
  7738 reseat_to_string (struct it *it, const char *s, Lisp_Object string,
  7739                   ptrdiff_t charpos, ptrdiff_t precision, int field_width,
  7740                   int multibyte)
  7741 {
  7742   /* No text property checks performed by default, but see below.  */
  7743   it->stop_charpos = -1;
  7744 
  7745   /* Set iterator position and end position.  */
  7746   memset (&it->current, 0, sizeof it->current);
  7747   it->current.overlay_string_index = -1;
  7748   it->current.dpvec_index = -1;
  7749   eassert (charpos >= 0);
  7750 
  7751   /* If STRING is specified, use its multibyteness, otherwise use the
  7752      setting of MULTIBYTE, if specified.  */
  7753   if (multibyte >= 0)
  7754     it->multibyte_p = multibyte > 0;
  7755 
  7756   /* Bidirectional reordering of strings is controlled by the default
  7757      value of bidi-display-reordering.  Don't try to reorder while
  7758      loading loadup.el, as the necessary character property tables are
  7759      not yet available.  */
  7760   it->bidi_p =
  7761     !redisplay__inhibit_bidi
  7762     && !NILP (BVAR (&buffer_defaults, bidi_display_reordering));
  7763 
  7764   if (s == NULL)
  7765     {
  7766       eassert (STRINGP (string));
  7767       it->string = string;
  7768       it->s = NULL;
  7769       it->end_charpos = it->string_nchars = SCHARS (string);
  7770       it->method = GET_FROM_STRING;
  7771       it->current.string_pos = string_pos (charpos, string);
  7772 
  7773       if (it->bidi_p)
  7774         {
  7775           it->bidi_it.string.lstring = string;
  7776           it->bidi_it.string.s = NULL;
  7777           it->bidi_it.string.schars = it->end_charpos;
  7778           it->bidi_it.string.bufpos = 0;
  7779           it->bidi_it.string.from_disp_str = false;
  7780           it->bidi_it.string.unibyte = !it->multibyte_p;
  7781           it->bidi_it.w = it->w;
  7782           bidi_init_it (charpos, IT_STRING_BYTEPOS (*it),
  7783                         FRAME_WINDOW_P (it->f), &it->bidi_it);
  7784         }
  7785     }
  7786   else
  7787     {
  7788       it->s = (const unsigned char *) s;
  7789       it->string = Qnil;
  7790 
  7791       /* Note that we use IT->current.pos, not it->current.string_pos,
  7792          for displaying C strings.  */
  7793       IT_STRING_CHARPOS (*it) = IT_STRING_BYTEPOS (*it) = -1;
  7794       if (it->multibyte_p)
  7795         {
  7796           it->current.pos = c_string_pos (charpos, s, true);
  7797           it->end_charpos = it->string_nchars = number_of_chars (s, true);
  7798         }
  7799       else
  7800         {
  7801           IT_CHARPOS (*it) = IT_BYTEPOS (*it) = charpos;
  7802           it->end_charpos = it->string_nchars = strlen (s);
  7803         }
  7804 
  7805       if (it->bidi_p)
  7806         {
  7807           it->bidi_it.string.lstring = Qnil;
  7808           it->bidi_it.string.s = (const unsigned char *) s;
  7809           it->bidi_it.string.schars = it->end_charpos;
  7810           it->bidi_it.string.bufpos = 0;
  7811           it->bidi_it.string.from_disp_str = false;
  7812           it->bidi_it.string.unibyte = !it->multibyte_p;
  7813           it->bidi_it.w = it->w;
  7814           bidi_init_it (charpos, IT_BYTEPOS (*it), FRAME_WINDOW_P (it->f),
  7815                         &it->bidi_it);
  7816         }
  7817       it->method = GET_FROM_C_STRING;
  7818     }
  7819 
  7820   /* PRECISION > 0 means don't return more than PRECISION characters
  7821      from the string.  */
  7822   if (precision > 0 && it->end_charpos - charpos > precision)
  7823     {
  7824       it->end_charpos = it->string_nchars = charpos + precision;
  7825       if (it->bidi_p)
  7826         it->bidi_it.string.schars = it->end_charpos;
  7827     }
  7828 
  7829   /* FIELD_WIDTH > 0 means pad with spaces until FIELD_WIDTH
  7830      characters have been returned.  FIELD_WIDTH == 0 means don't pad,
  7831      FIELD_WIDTH < 0 means infinite field width.  This is useful for
  7832      padding with `-' at the end of a mode line.  */
  7833   if (field_width < 0)
  7834     field_width = DISP_INFINITY;
  7835   /* Implementation note: We deliberately don't enlarge
  7836      it->bidi_it.string.schars here to fit it->end_charpos, because
  7837      the bidi iterator cannot produce characters out of thin air.  */
  7838   if (field_width > it->end_charpos - charpos)
  7839     it->end_charpos = charpos + field_width;
  7840 
  7841   /* Use the standard display table for displaying strings.  */
  7842   if (DISP_TABLE_P (Vstandard_display_table))
  7843     it->dp = XCHAR_TABLE (Vstandard_display_table);
  7844 
  7845   it->stop_charpos = charpos;
  7846   it->prev_stop = charpos;
  7847   it->base_level_stop = 0;
  7848   if (it->bidi_p)
  7849     {
  7850       it->bidi_it.first_elt = true;
  7851       it->bidi_it.paragraph_dir = NEUTRAL_DIR;
  7852       it->bidi_it.disp_pos = -1;
  7853     }
  7854   if (s == NULL && it->multibyte_p)
  7855     {
  7856       ptrdiff_t endpos = SCHARS (it->string);
  7857       if (endpos > it->end_charpos)
  7858         endpos = it->end_charpos;
  7859       composition_compute_stop_pos (&it->cmp_it, charpos, -1, endpos,
  7860                                     it->string, true);
  7861     }
  7862   CHECK_IT (it);
  7863 }
  7864 
  7865 
  7866 
  7867 /***********************************************************************
  7868                               Iteration
  7869 ***********************************************************************/
  7870 
  7871 /* Map enum it_method value to corresponding next_element_from_* function.  */
  7872 
  7873 typedef bool (*next_element_function) (struct it *);
  7874 
  7875 static next_element_function const get_next_element[NUM_IT_METHODS] =
  7876 {
  7877   next_element_from_buffer,
  7878   next_element_from_display_vector,
  7879   next_element_from_string,
  7880   next_element_from_c_string,
  7881   next_element_from_image,
  7882   next_element_from_stretch,
  7883   next_element_from_xwidget,
  7884 };
  7885 
  7886 #define GET_NEXT_DISPLAY_ELEMENT(it) (*get_next_element[(it)->method]) (it)
  7887 
  7888 
  7889 /* Return true iff a character at CHARPOS (and BYTEPOS) is composed
  7890    (possibly with the following characters).
  7891 
  7892   Note: we pass -1 as the "resolved bidi level" when the iterator
  7893   doesn't have the bidi_p flag set, because in that case we really
  7894   don't know what is the directionality of the text, so we leave it to
  7895   the shaping engine to figure that out.  */
  7896 
  7897 #define CHAR_COMPOSED_P(IT,CHARPOS,BYTEPOS,END_CHARPOS)                 \
  7898   ((IT)->cmp_it.id >= 0                                                 \
  7899    || ((IT)->cmp_it.stop_pos == (CHARPOS)                               \
  7900        && composition_reseat_it (&(IT)->cmp_it, CHARPOS, BYTEPOS,       \
  7901                                  END_CHARPOS, (IT)->w,                  \
  7902                                  (IT)->bidi_p                           \
  7903                                  ? (IT)->bidi_it.resolved_level         \
  7904                                  : -1,                                  \
  7905                                  FACE_FROM_ID_OR_NULL ((IT)->f,         \
  7906                                                        (IT)->face_id),  \
  7907                                  (IT)->string)))
  7908 
  7909 
  7910 /* Lookup the char-table Vglyphless_char_display for character C (-1
  7911    if we want information for no-font case), and return the display
  7912    method symbol.  By side-effect, update it->what and
  7913    it->glyphless_method.  This function is called from
  7914    get_next_display_element for each character element, and from
  7915    gui_produce_glyphs when no suitable font was found.  */
  7916 
  7917 Lisp_Object
  7918 lookup_glyphless_char_display (int c, struct it *it)
  7919 {
  7920   Lisp_Object glyphless_method = Qnil;
  7921 
  7922   if (CHAR_TABLE_P (Vglyphless_char_display)
  7923       && CHAR_TABLE_EXTRA_SLOTS (XCHAR_TABLE (Vglyphless_char_display)) >= 1)
  7924     {
  7925       if (c >= 0)
  7926         glyphless_method = CHAR_TABLE_REF (Vglyphless_char_display, c);
  7927       else
  7928         glyphless_method = XCHAR_TABLE (Vglyphless_char_display)->extras[0];
  7929 
  7930       if (CONSP (glyphless_method))
  7931         glyphless_method = FRAME_WINDOW_P (it->f)
  7932           ? XCAR (glyphless_method)
  7933           : XCDR (glyphless_method);
  7934     }
  7935 
  7936  retry:
  7937   if (NILP (glyphless_method))
  7938     {
  7939       if (c >= 0)
  7940         /* The default is to display the character by a proper font.  */
  7941         return Qnil;
  7942       /* The default for the no-font case is to display an empty box.  */
  7943       glyphless_method = Qempty_box;
  7944     }
  7945   if (EQ (glyphless_method, Qzero_width))
  7946     {
  7947       if (c >= 0)
  7948         return glyphless_method;
  7949       /* This method can't be used for the no-font case.  */
  7950       glyphless_method = Qempty_box;
  7951     }
  7952   if (EQ (glyphless_method, Qthin_space))
  7953     it->glyphless_method = GLYPHLESS_DISPLAY_THIN_SPACE;
  7954   else if (EQ (glyphless_method, Qempty_box))
  7955     it->glyphless_method = GLYPHLESS_DISPLAY_EMPTY_BOX;
  7956   else if (EQ (glyphless_method, Qhex_code))
  7957     it->glyphless_method = GLYPHLESS_DISPLAY_HEX_CODE;
  7958   else if (STRINGP (glyphless_method))
  7959     it->glyphless_method = GLYPHLESS_DISPLAY_ACRONYM;
  7960   else
  7961     {
  7962       /* Invalid value.  We use the default method.  */
  7963       glyphless_method = Qnil;
  7964       goto retry;
  7965     }
  7966   it->what = IT_GLYPHLESS;
  7967   return glyphless_method;
  7968 }
  7969 
  7970 /* Merge escape glyph face and cache the result.  */
  7971 
  7972 static struct frame *last_escape_glyph_frame = NULL;
  7973 static int last_escape_glyph_face_id = (1 << FACE_ID_BITS);
  7974 static int last_escape_glyph_merged_face_id = 0;
  7975 
  7976 static int
  7977 merge_escape_glyph_face (struct it *it)
  7978 {
  7979   int face_id;
  7980 
  7981   if (it->f == last_escape_glyph_frame
  7982       && it->face_id == last_escape_glyph_face_id)
  7983     face_id = last_escape_glyph_merged_face_id;
  7984   else
  7985     {
  7986       /* Merge the `escape-glyph' face into the current face.  */
  7987       face_id = merge_faces (it->w, Qescape_glyph, 0, it->face_id);
  7988       last_escape_glyph_frame = it->f;
  7989       last_escape_glyph_face_id = it->face_id;
  7990       last_escape_glyph_merged_face_id = face_id;
  7991     }
  7992   return face_id;
  7993 }
  7994 
  7995 /* Likewise for glyphless glyph face.  */
  7996 
  7997 static struct frame *last_glyphless_glyph_frame = NULL;
  7998 static int last_glyphless_glyph_face_id = (1 << FACE_ID_BITS);
  7999 static int last_glyphless_glyph_merged_face_id = 0;
  8000 
  8001 int
  8002 merge_glyphless_glyph_face (struct it *it)
  8003 {
  8004   int face_id;
  8005 
  8006   if (it->f == last_glyphless_glyph_frame
  8007       && it->face_id == last_glyphless_glyph_face_id)
  8008     face_id = last_glyphless_glyph_merged_face_id;
  8009   else
  8010     {
  8011       /* Merge the `glyphless-char' face into the current face.  */
  8012       face_id = merge_faces (it->w, Qglyphless_char, 0, it->face_id);
  8013       last_glyphless_glyph_frame = it->f;
  8014       last_glyphless_glyph_face_id = it->face_id;
  8015       last_glyphless_glyph_merged_face_id = face_id;
  8016     }
  8017   return face_id;
  8018 }
  8019 
  8020 /* Forget the `escape-glyph' and `glyphless-char' faces.  This should
  8021    be called before redisplaying windows, and when the frame's face
  8022    cache is freed.  */
  8023 void
  8024 forget_escape_and_glyphless_faces (void)
  8025 {
  8026   last_escape_glyph_frame = NULL;
  8027   last_escape_glyph_face_id = (1 << FACE_ID_BITS);
  8028   last_glyphless_glyph_frame = NULL;
  8029   last_glyphless_glyph_face_id = (1 << FACE_ID_BITS);
  8030 }
  8031 
  8032 /* Load IT's display element fields with information about the next
  8033    display element from the current position of IT.  Value is false if
  8034    end of buffer (or C string) is reached.  */
  8035 
  8036 static bool
  8037 get_next_display_element (struct it *it)
  8038 {
  8039   /* True means that we found a display element.  False means that
  8040      we hit the end of what we iterate over.  Performance note: the
  8041      function pointer `method' used here turns out to be faster than
  8042      using a sequence of if-statements.  */
  8043   bool success_p;
  8044 
  8045  get_next:
  8046   success_p = GET_NEXT_DISPLAY_ELEMENT (it);
  8047 
  8048   if (it->what == IT_CHARACTER)
  8049     {
  8050       /* UAX#9, L4: "A character is depicted by a mirrored glyph if
  8051          and only if (a) the resolved directionality of that character
  8052          is R..."  */
  8053       /* FIXME: Do we need an exception for characters from display
  8054          tables?  */
  8055       if (it->bidi_p && it->bidi_it.type == STRONG_R
  8056           && !inhibit_bidi_mirroring)
  8057         it->c = bidi_mirror_char (it->c);
  8058       /* Map via display table or translate control characters.
  8059          IT->c, IT->len etc. have been set to the next character by
  8060          the function call above.  If we have a display table, and it
  8061          contains an entry for IT->c, translate it.  Don't do this if
  8062          IT->c itself comes from a display table, otherwise we could
  8063          end up in an infinite recursion.  (An alternative could be to
  8064          count the recursion depth of this function and signal an
  8065          error when a certain maximum depth is reached.)  Is it worth
  8066          it?  */
  8067       if (success_p && it->dpvec == NULL)
  8068         {
  8069           Lisp_Object dv;
  8070           struct charset *unibyte = CHARSET_FROM_ID (charset_unibyte);
  8071           bool nonascii_space_p = false;
  8072           bool nonascii_hyphen_p = false;
  8073           int c = it->c;        /* This is the character to display.  */
  8074 
  8075           if (! it->multibyte_p && ! ASCII_CHAR_P (c))
  8076             {
  8077               eassert (SINGLE_BYTE_CHAR_P (c));
  8078               if (unibyte_display_via_language_environment)
  8079                 {
  8080                   c = DECODE_CHAR (unibyte, c);
  8081                   if (c < 0)
  8082                     c = BYTE8_TO_CHAR (it->c);
  8083                 }
  8084               else
  8085                 c = BYTE8_TO_CHAR (it->c);
  8086             }
  8087 
  8088           if (it->dp
  8089               && (dv = DISP_CHAR_VECTOR (it->dp, c),
  8090                   VECTORP (dv)))
  8091             {
  8092               struct Lisp_Vector *v = XVECTOR (dv);
  8093 
  8094               /* Return the first character from the display table
  8095                  entry, if not empty.  If empty, don't display the
  8096                  current character.  */
  8097               if (v->header.size)
  8098                 {
  8099                   it->dpvec_char_len = it->len;
  8100                   it->dpvec = v->contents;
  8101                   it->dpend = v->contents + v->header.size;
  8102                   it->current.dpvec_index = 0;
  8103                   it->dpvec_face_id = -1;
  8104                   it->saved_face_id = it->face_id;
  8105                   it->method = GET_FROM_DISPLAY_VECTOR;
  8106                   it->ellipsis_p = false;
  8107                 }
  8108               else
  8109                 {
  8110                   set_iterator_to_next (it, false);
  8111                 }
  8112               goto get_next;
  8113             }
  8114 
  8115           if (! NILP (lookup_glyphless_char_display (c, it)))
  8116             {
  8117               if (it->what == IT_GLYPHLESS)
  8118                 goto done;
  8119               /* Don't display this character.  */
  8120               set_iterator_to_next (it, false);
  8121               goto get_next;
  8122             }
  8123 
  8124           /* If `nobreak-char-display' is non-nil, we display
  8125              non-ASCII spaces and hyphens specially.  */
  8126           if (! ASCII_CHAR_P (c) && ! NILP (Vnobreak_char_display))
  8127             {
  8128               if (blankp (c))
  8129                 nonascii_space_p = true;
  8130               else if (c == SOFT_HYPHEN || c == HYPHEN
  8131                        || c == NON_BREAKING_HYPHEN)
  8132                 nonascii_hyphen_p = true;
  8133             }
  8134 
  8135           /* Translate control characters into `\003' or `^C' form.
  8136              Control characters coming from a display table entry are
  8137              currently not translated because we use IT->dpvec to hold
  8138              the translation.  This could easily be changed but I
  8139              don't believe that it is worth doing.
  8140 
  8141              The characters handled by `nobreak-char-display' must be
  8142              translated too.
  8143 
  8144              Non-printable characters and raw-byte characters are also
  8145              translated to octal or hexadecimal form.  */
  8146           if (((c < ' ' || c == 127) /* ASCII control chars.  */
  8147                ? (it->area != TEXT_AREA
  8148                   /* In mode line, treat \n, \t like other crl chars.  */
  8149                   || (c != '\t'
  8150                       && it->glyph_row
  8151                       && (it->glyph_row->mode_line_p || it->avoid_cursor_p))
  8152                   || (c != '\n' && c != '\t'))
  8153                : (nonascii_space_p
  8154                   || nonascii_hyphen_p
  8155                   || CHAR_BYTE8_P (c)
  8156                   || ! CHAR_PRINTABLE_P (c))))
  8157             {
  8158               /* C is a control character, non-ASCII space/hyphen,
  8159                  raw-byte, or a non-printable character which must be
  8160                  displayed either as '\003' or as `^C' where the '\\'
  8161                  and '^' can be defined in the display table.  Fill
  8162                  IT->ctl_chars with glyphs for what we have to
  8163                  display.  Then, set IT->dpvec to these glyphs.  */
  8164               Lisp_Object gc;
  8165               int ctl_len;
  8166               int face_id;
  8167               int lface_id = 0;
  8168               int escape_glyph;
  8169 
  8170               /* Handle control characters with ^.  */
  8171 
  8172               if (ASCII_CHAR_P (c) && it->ctl_arrow_p)
  8173                 {
  8174                   int g;
  8175 
  8176                   g = '^';           /* default glyph for Control */
  8177                   /* Set IT->ctl_chars[0] to the glyph for `^'.  */
  8178                   if (it->dp
  8179                       && (gc = DISP_CTRL_GLYPH (it->dp), GLYPH_CODE_P (gc)))
  8180                     {
  8181                       g = GLYPH_CODE_CHAR (gc);
  8182                       lface_id = GLYPH_CODE_FACE (gc);
  8183                     }
  8184 
  8185                   face_id = (lface_id
  8186                              ? merge_faces (it->w, Qt, lface_id, it->face_id)
  8187                              : merge_escape_glyph_face (it));
  8188 
  8189                   XSETINT (it->ctl_chars[0], g);
  8190                   XSETINT (it->ctl_chars[1], c ^ 0100);
  8191                   ctl_len = 2;
  8192                   goto display_control;
  8193                 }
  8194 
  8195               /* Handle non-ascii space in the mode where it only gets
  8196                  highlighting.  */
  8197 
  8198               if (nonascii_space_p && EQ (Vnobreak_char_display, Qt))
  8199                 {
  8200                   /* Merge `nobreak-space' into the current face.  */
  8201                   face_id = merge_faces (it->w, Qnobreak_space, 0,
  8202                                          it->face_id);
  8203                   XSETINT (it->ctl_chars[0],
  8204                            nobreak_char_ascii_display ? ' ' : it->c);
  8205                   ctl_len = 1;
  8206                   goto display_control;
  8207                 }
  8208 
  8209               /* Handle non-ascii hyphens in the mode where it only
  8210                  gets highlighting.  */
  8211 
  8212               if (nonascii_hyphen_p && EQ (Vnobreak_char_display, Qt))
  8213                 {
  8214                   /* Merge `nobreak-space' into the current face.  */
  8215                   face_id = merge_faces (it->w, Qnobreak_hyphen, 0,
  8216                                          it->face_id);
  8217                   XSETINT (it->ctl_chars[0],
  8218                            nobreak_char_ascii_display ? '-' : it->c);
  8219                   ctl_len = 1;
  8220                   goto display_control;
  8221                 }
  8222 
  8223               /* Handle sequences that start with the "escape glyph".  */
  8224 
  8225               /* the default escape glyph is \.  */
  8226               escape_glyph = '\\';
  8227 
  8228               if (it->dp
  8229                   && (gc = DISP_ESCAPE_GLYPH (it->dp), GLYPH_CODE_P (gc)))
  8230                 {
  8231                   escape_glyph = GLYPH_CODE_CHAR (gc);
  8232                   lface_id = GLYPH_CODE_FACE (gc);
  8233                 }
  8234 
  8235               face_id = (lface_id
  8236                          ? merge_faces (it->w, Qt, lface_id, it->face_id)
  8237                          : merge_escape_glyph_face (it));
  8238 
  8239               /* Draw non-ASCII space/hyphen with escape glyph: */
  8240 
  8241               if (nonascii_space_p || nonascii_hyphen_p)
  8242                 {
  8243                   XSETINT (it->ctl_chars[0], escape_glyph);
  8244                   XSETINT (it->ctl_chars[1], nonascii_space_p ? ' ' : '-');
  8245                   ctl_len = 2;
  8246                   goto display_control;
  8247                 }
  8248 
  8249               {
  8250                 char str[10];
  8251                 int len, i;
  8252 
  8253                 if (CHAR_BYTE8_P (c))
  8254                   /* Display \200 or \x80 instead of \17777600.  */
  8255                   c = CHAR_TO_BYTE8 (c);
  8256                 const char *format_string = display_raw_bytes_as_hex
  8257                                             ? "x%02x"
  8258                                             : "%03o";
  8259                 len = sprintf (str, format_string, c + 0u);
  8260 
  8261                 XSETINT (it->ctl_chars[0], escape_glyph);
  8262                 for (i = 0; i < len; i++)
  8263                   XSETINT (it->ctl_chars[i + 1], str[i]);
  8264                 ctl_len = len + 1;
  8265               }
  8266 
  8267             display_control:
  8268               /* Set up IT->dpvec and return first character from it.  */
  8269               it->dpvec_char_len = it->len;
  8270               it->dpvec = it->ctl_chars;
  8271               it->dpend = it->dpvec + ctl_len;
  8272               it->current.dpvec_index = 0;
  8273               it->dpvec_face_id = face_id;
  8274               it->saved_face_id = it->face_id;
  8275               it->method = GET_FROM_DISPLAY_VECTOR;
  8276               it->ellipsis_p = false;
  8277               goto get_next;
  8278             }
  8279           it->char_to_display = c;
  8280         }
  8281       else if (success_p)
  8282         {
  8283           it->char_to_display = it->c;
  8284         }
  8285     }
  8286 
  8287 #ifdef HAVE_WINDOW_SYSTEM
  8288   /* Adjust face id for a multibyte character.  There are no multibyte
  8289      character in unibyte text.  */
  8290   if ((it->what == IT_CHARACTER || it->what == IT_COMPOSITION)
  8291       && it->multibyte_p
  8292       && success_p
  8293       && FRAME_WINDOW_P (it->f))
  8294     {
  8295       struct face *face = FACE_FROM_ID (it->f, it->face_id);
  8296 
  8297       if (it->what == IT_COMPOSITION && it->cmp_it.ch >= 0)
  8298         {
  8299           /* Automatic composition with glyph-string.   */
  8300           Lisp_Object gstring = composition_gstring_from_id (it->cmp_it.id);
  8301 
  8302           it->face_id = face_for_font (it->f, LGSTRING_FONT (gstring), face);
  8303         }
  8304       else
  8305         {
  8306           ptrdiff_t pos = (it->s ? -1
  8307                      : STRINGP (it->string) ? IT_STRING_CHARPOS (*it)
  8308                      : IT_CHARPOS (*it));
  8309           int c;
  8310 
  8311           if (it->what == IT_CHARACTER)
  8312             c = it->char_to_display;
  8313           else
  8314             {
  8315               struct composition *cmp = composition_table[it->cmp_it.id];
  8316               int i;
  8317 
  8318               c = ' ';
  8319               for (i = 0; i < cmp->glyph_len; i++)
  8320                 /* TAB in a composition means display glyphs with
  8321                    padding space on the left or right.  */
  8322                 if ((c = COMPOSITION_GLYPH (cmp, i)) != '\t')
  8323                   break;
  8324             }
  8325           it->face_id = FACE_FOR_CHAR (it->f, face, c, pos, it->string);
  8326         }
  8327     }
  8328 #endif  /* HAVE_WINDOW_SYSTEM */
  8329 
  8330  done:
  8331   /* Is this character the last one of a run of characters with
  8332      box?  If yes, set IT->end_of_box_run_p to true.  */
  8333   if (it->face_box_p
  8334       && it->s == NULL)
  8335     {
  8336       if (it->method == GET_FROM_STRING && it->sp)
  8337         {
  8338           int face_id = underlying_face_id (it);
  8339           struct face *face = FACE_FROM_ID_OR_NULL (it->f, face_id);
  8340 
  8341           if (face)
  8342             {
  8343               if (face->box == FACE_NO_BOX)
  8344                 {
  8345                   /* If the box comes from face properties in a
  8346                      display string, check faces in that string.  */
  8347                   int string_face_id = face_after_it_pos (it);
  8348                   if (FACE_FROM_ID (it->f, string_face_id)->box == FACE_NO_BOX)
  8349                     it->end_of_box_run_p = true;
  8350                 }
  8351               /* Otherwise, the box comes from the underlying face.
  8352                  If this is the last string character displayed, check
  8353                  the next buffer location.  */
  8354               else if (((IT_STRING_CHARPOS (*it) >= SCHARS (it->string) - 1)
  8355                         /* For a composition, see if the string ends
  8356                            at the last character included in the
  8357                            composition.  */
  8358                         || (it->what == IT_COMPOSITION
  8359                             && (IT_STRING_CHARPOS (*it) + it->cmp_it.nchars
  8360                                 >= SCHARS (it->string))))
  8361                        /* n_overlay_strings is unreliable unless
  8362                           overlay_string_index is non-negative.  */
  8363                        && ((it->current.overlay_string_index >= 0
  8364                             && (it->current.overlay_string_index
  8365                                 == it->n_overlay_strings - 1))
  8366                            /* A string from display property.  */
  8367                            || it->from_disp_prop_p))
  8368                 {
  8369                   ptrdiff_t ignore;
  8370                   int next_face_id;
  8371                   bool text_from_string = false;
  8372                   /* Normally, the next buffer location is stored in
  8373                      IT->current.pos...  */
  8374                   struct text_pos pos = it->current.pos;
  8375 
  8376                   /* ...but for a string from a display property, the
  8377                      next buffer position is stored in the 'position'
  8378                      member of the iteration stack slot below the
  8379                      current one, see handle_single_display_spec.  By
  8380                      contrast, it->current.pos was not yet updated to
  8381                      point to that buffer position; that will happen
  8382                      in pop_it, after we finish displaying the current
  8383                      string.  Note that we already checked above that
  8384                      it->sp is positive, so subtracting one from it is
  8385                      safe.  */
  8386                   if (it->from_disp_prop_p)
  8387                     {
  8388                       int stackp = it->sp - 1;
  8389 
  8390                       /* Find the stack level with data from buffer.  */
  8391                       while (stackp >= 0
  8392                              && STRINGP ((it->stack + stackp)->string))
  8393                         stackp--;
  8394                       if (stackp < 0)
  8395                         {
  8396                           /* If no stack slot was found for iterating
  8397                              a buffer, we are displaying text from a
  8398                              string, most probably the mode line or
  8399                              the header line, and that string has a
  8400                              display string on some of its
  8401                              characters.  */
  8402                           text_from_string = true;
  8403                           pos = it->stack[it->sp - 1].position;
  8404                         }
  8405                       else
  8406                         pos = (it->stack + stackp)->position;
  8407                     }
  8408                   else
  8409                     INC_TEXT_POS (pos, it->multibyte_p);
  8410 
  8411                   if (text_from_string)
  8412                     {
  8413                       Lisp_Object base_string = it->stack[it->sp - 1].string;
  8414 
  8415                       if (CHARPOS (pos) >= SCHARS (base_string) - 1)
  8416                         it->end_of_box_run_p = true;
  8417                       else
  8418                         {
  8419                           next_face_id
  8420                             = face_at_string_position (it->w, base_string,
  8421                                                        CHARPOS (pos), 0,
  8422                                                        &ignore, face_id,
  8423                                                        false, 0);
  8424                           if (FACE_FROM_ID (it->f, next_face_id)->box
  8425                               == FACE_NO_BOX)
  8426                             it->end_of_box_run_p = true;
  8427                         }
  8428                     }
  8429                   else if (CHARPOS (pos) >= ZV)
  8430                     it->end_of_box_run_p = true;
  8431                   else
  8432                     {
  8433                       next_face_id =
  8434                         face_at_buffer_position (it->w, CHARPOS (pos),
  8435                                                  &ignore,
  8436                                                  CHARPOS (pos)
  8437                                                  + TEXT_PROP_DISTANCE_LIMIT,
  8438                                                  false, -1, 0);
  8439                       if (FACE_FROM_ID (it->f, next_face_id)->box
  8440                           == FACE_NO_BOX)
  8441                         it->end_of_box_run_p = true;
  8442                     }
  8443                 }
  8444             }
  8445         }
  8446       /* next_element_from_display_vector sets this flag according to
  8447          faces of the display vector glyphs, see there.  */
  8448       else if (it->method != GET_FROM_DISPLAY_VECTOR)
  8449         {
  8450           int face_id = face_after_it_pos (it);
  8451           if (face_id != it->face_id
  8452               && FACE_FROM_ID (it->f, face_id)->box == FACE_NO_BOX)
  8453             it->end_of_box_run_p = true;
  8454         }
  8455     }
  8456   /* If we reached the end of the object we've been iterating (e.g., a
  8457      display string or an overlay string), and there's something on
  8458      IT->stack, proceed with what's on the stack.  It doesn't make
  8459      sense to return false if there's unprocessed stuff on the stack,
  8460      because otherwise that stuff will never be displayed.  */
  8461   if (!success_p && it->sp > 0)
  8462     {
  8463       set_iterator_to_next (it, false);
  8464       success_p = get_next_display_element (it);
  8465     }
  8466 
  8467   /* Value is false if end of buffer or string reached.  */
  8468   return success_p;
  8469 }
  8470 
  8471 
  8472 /* Move IT to the next display element.
  8473 
  8474    RESEAT_P means if called on a newline in buffer text,
  8475    skip to the next visible line start.
  8476 
  8477    Functions get_next_display_element and set_iterator_to_next are
  8478    separate because I find this arrangement easier to handle than a
  8479    get_next_display_element function that also increments IT's
  8480    position.  The way it is we can first look at an iterator's current
  8481    display element, decide whether it fits on a line, and if it does,
  8482    increment the iterator position.  The other way around we probably
  8483    would either need a flag indicating whether the iterator has to be
  8484    incremented the next time, or we would have to implement a
  8485    decrement position function which would not be easy to write.  */
  8486 
  8487 void
  8488 set_iterator_to_next (struct it *it, bool reseat_p)
  8489 {
  8490 
  8491   if (max_redisplay_ticks > 0)
  8492     update_redisplay_ticks (1, it->w);
  8493 
  8494   switch (it->method)
  8495     {
  8496     case GET_FROM_BUFFER:
  8497       /* The current display element of IT is a character from
  8498          current_buffer.  Advance in the buffer, and maybe skip over
  8499          invisible lines that are so because of selective display.  */
  8500       if (ITERATOR_AT_END_OF_LINE_P (it) && reseat_p)
  8501         reseat_at_next_visible_line_start (it, false);
  8502       else if (it->cmp_it.id >= 0)
  8503         {
  8504           /* We are currently getting glyphs from a composition.  */
  8505           if (! it->bidi_p)
  8506             {
  8507               IT_CHARPOS (*it) += it->cmp_it.nchars;
  8508               IT_BYTEPOS (*it) += it->cmp_it.nbytes;
  8509             }
  8510           else
  8511             {
  8512               int i;
  8513 
  8514               /* Update IT's char/byte positions to point to the first
  8515                  character of the next grapheme cluster, or to the
  8516                  character visually after the current composition.  */
  8517               for (i = 0; i < it->cmp_it.nchars; i++)
  8518                 bidi_move_to_visually_next (&it->bidi_it);
  8519               IT_BYTEPOS (*it) = it->bidi_it.bytepos;
  8520               IT_CHARPOS (*it) = it->bidi_it.charpos;
  8521             }
  8522 
  8523           if ((! it->bidi_p || ! it->cmp_it.reversed_p)
  8524               && it->cmp_it.to < it->cmp_it.nglyphs)
  8525             {
  8526               /* Composition created while scanning forward.  Proceed
  8527                  to the next grapheme cluster.  */
  8528               it->cmp_it.from = it->cmp_it.to;
  8529             }
  8530           else if ((it->bidi_p && it->cmp_it.reversed_p)
  8531                    && it->cmp_it.from > 0)
  8532             {
  8533               /* Composition created while scanning backward.  Proceed
  8534                  to the previous grapheme cluster.  */
  8535               it->cmp_it.to = it->cmp_it.from;
  8536             }
  8537           else
  8538             {
  8539               /* No more grapheme clusters in this composition.
  8540                  Find the next stop position.  */
  8541               ptrdiff_t stop = it->end_charpos;
  8542 
  8543               if (it->bidi_it.scan_dir < 0)
  8544                 /* Now we are scanning backward and don't know
  8545                    where to stop.  */
  8546                 stop = -1;
  8547               composition_compute_stop_pos (&it->cmp_it, IT_CHARPOS (*it),
  8548                                             IT_BYTEPOS (*it), stop, Qnil, true);
  8549             }
  8550         }
  8551       else
  8552         {
  8553           eassert (it->len != 0);
  8554 
  8555           if (!it->bidi_p)
  8556             {
  8557               IT_BYTEPOS (*it) += it->len;
  8558               IT_CHARPOS (*it) += 1;
  8559             }
  8560           else
  8561             {
  8562               int prev_scan_dir = it->bidi_it.scan_dir;
  8563               /* If this is a new paragraph, determine its base
  8564                  direction (a.k.a. its base embedding level).  */
  8565               if (it->bidi_it.new_paragraph)
  8566                 bidi_paragraph_init (it->paragraph_embedding, &it->bidi_it,
  8567                                      false);
  8568               bidi_move_to_visually_next (&it->bidi_it);
  8569               IT_BYTEPOS (*it) = it->bidi_it.bytepos;
  8570               IT_CHARPOS (*it) = it->bidi_it.charpos;
  8571               if (prev_scan_dir != it->bidi_it.scan_dir)
  8572                 {
  8573                   /* As the scan direction was changed, we must
  8574                      re-compute the stop position for composition.  */
  8575                   ptrdiff_t stop = it->end_charpos;
  8576                   if (it->bidi_it.scan_dir < 0)
  8577                     stop = -1;
  8578                   composition_compute_stop_pos (&it->cmp_it, IT_CHARPOS (*it),
  8579                                                 IT_BYTEPOS (*it), stop, Qnil,
  8580                                                 true);
  8581                 }
  8582             }
  8583           eassert (IT_BYTEPOS (*it) == CHAR_TO_BYTE (IT_CHARPOS (*it)));
  8584         }
  8585       break;
  8586 
  8587     case GET_FROM_C_STRING:
  8588       /* Current display element of IT is from a C string.  */
  8589       if (!it->bidi_p
  8590           /* If the string position is beyond string's end, it means
  8591              next_element_from_c_string is padding the string with
  8592              blanks, in which case we bypass the bidi iterator,
  8593              because it cannot deal with such virtual characters.  */
  8594           || IT_CHARPOS (*it) >= it->bidi_it.string.schars)
  8595         {
  8596           IT_BYTEPOS (*it) += it->len;
  8597           IT_CHARPOS (*it) += 1;
  8598         }
  8599       else
  8600         {
  8601           bidi_move_to_visually_next (&it->bidi_it);
  8602           IT_BYTEPOS (*it) = it->bidi_it.bytepos;
  8603           IT_CHARPOS (*it) = it->bidi_it.charpos;
  8604         }
  8605       break;
  8606 
  8607     case GET_FROM_DISPLAY_VECTOR:
  8608       /* Current display element of IT is from a display table entry.
  8609          Advance in the display table definition.  Reset it to null if
  8610          end reached, and continue with characters from buffers/
  8611          strings.  */
  8612       ++it->current.dpvec_index;
  8613 
  8614       /* Restore face of the iterator to what they were before the
  8615          display vector entry (these entries may contain faces).  */
  8616       it->face_id = it->saved_face_id;
  8617 
  8618       if (it->dpvec + it->current.dpvec_index >= it->dpend)
  8619         {
  8620           bool recheck_faces = it->ellipsis_p;
  8621 
  8622           if (it->s)
  8623             it->method = GET_FROM_C_STRING;
  8624           else if (STRINGP (it->string))
  8625             it->method = GET_FROM_STRING;
  8626           else
  8627             {
  8628               it->method = GET_FROM_BUFFER;
  8629               it->object = it->w->contents;
  8630             }
  8631 
  8632           it->dpvec = NULL;
  8633           it->current.dpvec_index = -1;
  8634 
  8635           /* Skip over characters which were displayed via IT->dpvec.  */
  8636           if (it->dpvec_char_len < 0)
  8637             reseat_at_next_visible_line_start (it, true);
  8638           else if (it->dpvec_char_len > 0)
  8639             {
  8640               it->len = it->dpvec_char_len;
  8641               set_iterator_to_next (it, reseat_p);
  8642             }
  8643 
  8644           /* Maybe recheck faces after display vector.  */
  8645           if (recheck_faces)
  8646             {
  8647               if (it->method == GET_FROM_STRING)
  8648                 it->stop_charpos = IT_STRING_CHARPOS (*it);
  8649               else
  8650                 it->stop_charpos = IT_CHARPOS (*it);
  8651             }
  8652         }
  8653       break;
  8654 
  8655     case GET_FROM_STRING:
  8656       /* Current display element is a character from a Lisp string.  */
  8657       eassert (it->s == NULL && STRINGP (it->string));
  8658       /* Don't advance past string end.  These conditions are true
  8659          when set_iterator_to_next is called at the end of
  8660          get_next_display_element, in which case the Lisp string is
  8661          already exhausted, and all we want is pop the iterator
  8662          stack.  */
  8663       if (it->current.overlay_string_index >= 0)
  8664         {
  8665           /* This is an overlay string, so there's no padding with
  8666              spaces, and the number of characters in the string is
  8667              where the string ends.  */
  8668           if (IT_STRING_CHARPOS (*it) >= SCHARS (it->string))
  8669             goto consider_string_end;
  8670         }
  8671       else
  8672         {
  8673           /* Not an overlay string.  There could be padding, so test
  8674              against it->end_charpos.  */
  8675           if (IT_STRING_CHARPOS (*it) >= it->end_charpos)
  8676             goto consider_string_end;
  8677         }
  8678       if (it->cmp_it.id >= 0)
  8679         {
  8680           /* We are delivering display elements from a composition.
  8681              Update the string position past the grapheme cluster
  8682              we've just processed.  */
  8683           if (! it->bidi_p)
  8684             {
  8685               IT_STRING_CHARPOS (*it) += it->cmp_it.nchars;
  8686               IT_STRING_BYTEPOS (*it) += it->cmp_it.nbytes;
  8687             }
  8688           else
  8689             {
  8690               int i;
  8691 
  8692               for (i = 0; i < it->cmp_it.nchars; i++)
  8693                 bidi_move_to_visually_next (&it->bidi_it);
  8694               IT_STRING_BYTEPOS (*it) = it->bidi_it.bytepos;
  8695               IT_STRING_CHARPOS (*it) = it->bidi_it.charpos;
  8696             }
  8697 
  8698           /* Did we exhaust all the grapheme clusters of this
  8699              composition?  */
  8700           if ((! it->bidi_p || ! it->cmp_it.reversed_p)
  8701               && (it->cmp_it.to < it->cmp_it.nglyphs))
  8702             {
  8703               /* Not all the grapheme clusters were processed yet;
  8704                  advance to the next cluster.  */
  8705               it->cmp_it.from = it->cmp_it.to;
  8706             }
  8707           else if ((it->bidi_p && it->cmp_it.reversed_p)
  8708                    && it->cmp_it.from > 0)
  8709             {
  8710               /* Likewise: advance to the next cluster, but going in
  8711                  the reverse direction.  */
  8712               it->cmp_it.to = it->cmp_it.from;
  8713             }
  8714           else
  8715             {
  8716               /* This composition was fully processed; find the next
  8717                  candidate place for checking for composed
  8718                  characters.  */
  8719               /* Always limit string searches to the string length;
  8720                  any padding spaces are not part of the string, and
  8721                  there cannot be any compositions in that padding.  */
  8722               ptrdiff_t stop = SCHARS (it->string);
  8723 
  8724               if (it->bidi_p && it->bidi_it.scan_dir < 0)
  8725                 stop = -1;
  8726               else if (it->end_charpos < stop)
  8727                 {
  8728                   /* Cf. PRECISION in reseat_to_string: we might be
  8729                      limited in how many of the string characters we
  8730                      need to deliver.  */
  8731                   stop = it->end_charpos;
  8732                 }
  8733               composition_compute_stop_pos (&it->cmp_it,
  8734                                             IT_STRING_CHARPOS (*it),
  8735                                             IT_STRING_BYTEPOS (*it), stop,
  8736                                             it->string, true);
  8737             }
  8738         }
  8739       else
  8740         {
  8741           if (!it->bidi_p
  8742               /* If the string position is beyond string's end, it
  8743                  means next_element_from_string is padding the string
  8744                  with blanks, in which case we bypass the bidi
  8745                  iterator, because it cannot deal with such virtual
  8746                  characters.  */
  8747               || IT_STRING_CHARPOS (*it) >= it->bidi_it.string.schars)
  8748             {
  8749               IT_STRING_BYTEPOS (*it) += it->len;
  8750               IT_STRING_CHARPOS (*it) += 1;
  8751             }
  8752           else
  8753             {
  8754               int prev_scan_dir = it->bidi_it.scan_dir;
  8755 
  8756               bidi_move_to_visually_next (&it->bidi_it);
  8757               IT_STRING_BYTEPOS (*it) = it->bidi_it.bytepos;
  8758               IT_STRING_CHARPOS (*it) = it->bidi_it.charpos;
  8759               /* If the scan direction changes, we may need to update
  8760                  the place where to check for composed characters.  */
  8761               if (prev_scan_dir != it->bidi_it.scan_dir)
  8762                 {
  8763                   ptrdiff_t stop = SCHARS (it->string);
  8764 
  8765                   if (it->bidi_it.scan_dir < 0)
  8766                     stop = -1;
  8767                   else if (it->end_charpos < stop)
  8768                     stop = it->end_charpos;
  8769 
  8770                   composition_compute_stop_pos (&it->cmp_it,
  8771                                                 IT_STRING_CHARPOS (*it),
  8772                                                 IT_STRING_BYTEPOS (*it), stop,
  8773                                                 it->string, true);
  8774                 }
  8775             }
  8776         }
  8777 
  8778     consider_string_end:
  8779 
  8780       if (it->current.overlay_string_index >= 0)
  8781         {
  8782           /* IT->string is an overlay string.  Advance to the
  8783              next, if there is one.  */
  8784           if (IT_STRING_CHARPOS (*it) >= SCHARS (it->string))
  8785             {
  8786               it->ellipsis_p = false;
  8787               next_overlay_string (it);
  8788               if (it->ellipsis_p)
  8789                 setup_for_ellipsis (it, 0);
  8790             }
  8791         }
  8792       else
  8793         {
  8794           /* IT->string is not an overlay string.  If we reached
  8795              its end, and there is something on IT->stack, proceed
  8796              with what is on the stack.  This can be either another
  8797              string, this time an overlay string, or a buffer.  */
  8798           if (IT_STRING_CHARPOS (*it) == SCHARS (it->string)
  8799               && it->sp > 0)
  8800             {
  8801               pop_it (it);
  8802               if (it->method == GET_FROM_STRING)
  8803                 goto consider_string_end;
  8804             }
  8805         }
  8806       break;
  8807 
  8808     case GET_FROM_IMAGE:
  8809     case GET_FROM_STRETCH:
  8810     case GET_FROM_XWIDGET:
  8811 
  8812       /* The position etc with which we have to proceed are on
  8813          the stack.  The position may be at the end of a string,
  8814          if the `display' property takes up the whole string.  */
  8815       eassert (it->sp > 0);
  8816       pop_it (it);
  8817       if (it->method == GET_FROM_STRING)
  8818         goto consider_string_end;
  8819       break;
  8820 
  8821     default:
  8822       /* There are no other methods defined, so this should be a bug.  */
  8823       emacs_abort ();
  8824     }
  8825 
  8826   eassert (it->method != GET_FROM_STRING
  8827            || (STRINGP (it->string)
  8828                && IT_STRING_CHARPOS (*it) >= 0));
  8829 }
  8830 
  8831 /* Load IT's display element fields with information about the next
  8832    display element which comes from a display table entry or from the
  8833    result of translating a control character to one of the forms `^C'
  8834    or `\003'.
  8835 
  8836    IT->dpvec holds the glyphs to return as characters.
  8837    IT->saved_face_id holds the face id before the display vector--it
  8838    is restored into IT->face_id in set_iterator_to_next.  */
  8839 
  8840 static bool
  8841 next_element_from_display_vector (struct it *it)
  8842 {
  8843   Lisp_Object gc;
  8844   int prev_face_id = it->face_id;
  8845   int next_face_id;
  8846 
  8847   /* Precondition.  */
  8848   eassert (it->dpvec && it->current.dpvec_index >= 0);
  8849 
  8850   it->face_id = it->saved_face_id;
  8851 
  8852   /* KFS: This code used to check ip->dpvec[0] instead of the current element.
  8853      That seemed totally bogus - so I changed it...  */
  8854   if (it->dpend - it->dpvec > 0 /* empty dpvec[] is invalid */
  8855       && (gc = it->dpvec[it->current.dpvec_index], GLYPH_CODE_P (gc)))
  8856     {
  8857       struct face *this_face, *prev_face, *next_face;
  8858 
  8859       it->c = GLYPH_CODE_CHAR (gc);
  8860       it->len = CHAR_BYTES (it->c);
  8861 
  8862       /* The entry may contain a face id to use.  Such a face id is
  8863          the id of a Lisp face, not a realized face.  A face id of
  8864          zero means no face is specified.  */
  8865       if (it->dpvec_face_id >= 0)
  8866         it->face_id = it->dpvec_face_id;
  8867       else
  8868         {
  8869           int lface_id = GLYPH_CODE_FACE (gc);
  8870           if (lface_id > 0)
  8871             it->face_id = merge_faces (it->w, Qt, lface_id,
  8872                                        it->saved_face_id);
  8873         }
  8874 
  8875       /* Glyphs in the display vector could have the box face, so we
  8876          need to set the related flags in the iterator, as
  8877          appropriate.  */
  8878       this_face = FACE_FROM_ID_OR_NULL (it->f, it->face_id);
  8879       prev_face = FACE_FROM_ID_OR_NULL (it->f, prev_face_id);
  8880 
  8881       /* Is this character the first character of a box-face run?  */
  8882       it->start_of_box_run_p = (this_face && this_face->box != FACE_NO_BOX
  8883                                 && (!prev_face
  8884                                     || prev_face->box == FACE_NO_BOX));
  8885 
  8886       /* For the last character of the box-face run, we need to look
  8887          either at the next glyph from the display vector, or at the
  8888          face we saw before the display vector.  */
  8889       next_face_id = it->saved_face_id;
  8890       if (it->current.dpvec_index < it->dpend - it->dpvec - 1)
  8891         {
  8892           if (it->dpvec_face_id >= 0)
  8893             next_face_id = it->dpvec_face_id;
  8894           else
  8895             {
  8896               Lisp_Object gc = it->dpvec[it->current.dpvec_index + 1];
  8897               int lface_id = GLYPH_CODE_P (gc) ? GLYPH_CODE_FACE (gc) : 0;
  8898 
  8899               if (lface_id > 0)
  8900                 next_face_id = merge_faces (it->w, Qt, lface_id,
  8901                                             it->saved_face_id);
  8902             }
  8903         }
  8904       next_face = FACE_FROM_ID_OR_NULL (it->f, next_face_id);
  8905       if (this_face && this_face->box != FACE_NO_BOX
  8906           && (!next_face || next_face->box == FACE_NO_BOX))
  8907         it->end_of_box_run_p = true;
  8908       it->face_box_p = this_face && this_face->box != FACE_NO_BOX;
  8909     }
  8910   else
  8911     /* Display table entry is invalid.  Return a space.  */
  8912     it->c = ' ', it->len = 1;
  8913 
  8914   /* Don't change position and object of the iterator here.  They are
  8915      still the values of the character that had this display table
  8916      entry or was translated, and that's what we want.  */
  8917   it->what = IT_CHARACTER;
  8918   return true;
  8919 }
  8920 
  8921 /* Get the first element of string/buffer in the visual order, after
  8922    being reseated to a new position in a string or a buffer.  */
  8923 static void
  8924 get_visually_first_element (struct it *it)
  8925 {
  8926   bool string_p = STRINGP (it->string) || it->s;
  8927   ptrdiff_t eob = (string_p ? it->bidi_it.string.schars : ZV);
  8928   ptrdiff_t bob;
  8929   ptrdiff_t obegv = BEGV;
  8930 
  8931   SET_WITH_NARROWED_BEGV (it, bob,
  8932                           string_p ? 0 :
  8933                           IT_CHARPOS (*it) < BEGV ? obegv : BEGV,
  8934                           it->medium_narrowing_begv);
  8935 
  8936   if (STRINGP (it->string))
  8937     {
  8938       it->bidi_it.charpos = IT_STRING_CHARPOS (*it);
  8939       it->bidi_it.bytepos = IT_STRING_BYTEPOS (*it);
  8940     }
  8941   else
  8942     {
  8943       it->bidi_it.charpos = IT_CHARPOS (*it);
  8944       it->bidi_it.bytepos = IT_BYTEPOS (*it);
  8945     }
  8946 
  8947   if (it->bidi_it.charpos == eob)
  8948     {
  8949       /* Nothing to do, but reset the FIRST_ELT flag, like
  8950          bidi_paragraph_init does, because we are not going to
  8951          call it.  */
  8952       it->bidi_it.first_elt = false;
  8953     }
  8954   else if (it->bidi_it.charpos == bob
  8955            || (!string_p
  8956                && (FETCH_BYTE (it->bidi_it.bytepos - 1) == '\n'
  8957                    || FETCH_BYTE (it->bidi_it.bytepos) == '\n')))
  8958     {
  8959       /* If we are at the beginning of a line/string, we can produce
  8960          the next element right away.  */
  8961       bidi_paragraph_init (it->paragraph_embedding, &it->bidi_it, true);
  8962       bidi_move_to_visually_next (&it->bidi_it);
  8963     }
  8964   else
  8965     {
  8966       ptrdiff_t orig_bytepos = it->bidi_it.bytepos;
  8967 
  8968       /* We need to prime the bidi iterator starting at the line's or
  8969          string's beginning, before we will be able to produce the
  8970          next element.  */
  8971       if (string_p)
  8972         it->bidi_it.charpos = it->bidi_it.bytepos = 0;
  8973       else
  8974         SET_WITH_NARROWED_BEGV (it, it->bidi_it.charpos,
  8975                                 find_newline_no_quit (IT_CHARPOS (*it),
  8976                                                       IT_BYTEPOS (*it), -1,
  8977                                                       &it->bidi_it.bytepos),
  8978                                 it->medium_narrowing_begv);
  8979       bidi_paragraph_init (it->paragraph_embedding, &it->bidi_it, true);
  8980       do
  8981         {
  8982           /* Now return to buffer/string position where we were asked
  8983              to get the next display element, and produce that.  */
  8984           bidi_move_to_visually_next (&it->bidi_it);
  8985         }
  8986       while (it->bidi_it.bytepos != orig_bytepos
  8987              && it->bidi_it.charpos < eob);
  8988     }
  8989 
  8990   /*  Adjust IT's position information to where we ended up.  */
  8991   if (STRINGP (it->string))
  8992     {
  8993       IT_STRING_CHARPOS (*it) = it->bidi_it.charpos;
  8994       IT_STRING_BYTEPOS (*it) = it->bidi_it.bytepos;
  8995     }
  8996   else
  8997     {
  8998       IT_CHARPOS (*it) = it->bidi_it.charpos;
  8999       IT_BYTEPOS (*it) = it->bidi_it.bytepos;
  9000     }
  9001 
  9002   if (STRINGP (it->string) || !it->s)
  9003     {
  9004       ptrdiff_t stop, charpos, bytepos;
  9005 
  9006       if (STRINGP (it->string))
  9007         {
  9008           eassert (!it->s);
  9009           stop = SCHARS (it->string);
  9010           if (stop > it->end_charpos)
  9011             stop = it->end_charpos;
  9012           charpos = IT_STRING_CHARPOS (*it);
  9013           bytepos = IT_STRING_BYTEPOS (*it);
  9014         }
  9015       else
  9016         {
  9017           stop = it->end_charpos;
  9018           charpos = IT_CHARPOS (*it);
  9019           bytepos = IT_BYTEPOS (*it);
  9020         }
  9021       if (it->bidi_it.scan_dir < 0)
  9022         stop = -1;
  9023       composition_compute_stop_pos (&it->cmp_it, charpos, bytepos, stop,
  9024                                     it->string, true);
  9025     }
  9026 }
  9027 
  9028 /* Load IT with the next display element from Lisp string IT->string.
  9029    IT->current.string_pos is the current position within the string.
  9030    If IT->current.overlay_string_index >= 0, the Lisp string is an
  9031    overlay string.  */
  9032 
  9033 static bool
  9034 next_element_from_string (struct it *it)
  9035 {
  9036   struct text_pos position;
  9037 
  9038   eassert (STRINGP (it->string));
  9039   eassert (!it->bidi_p || EQ (it->string, it->bidi_it.string.lstring));
  9040   eassert (IT_STRING_CHARPOS (*it) >= 0);
  9041   position = it->current.string_pos;
  9042 
  9043   /* With bidi reordering, the character to display might not be the
  9044      character at IT_STRING_CHARPOS.  BIDI_IT.FIRST_ELT means
  9045      that we were reseat()ed to a new string, whose paragraph
  9046      direction is not known.  */
  9047   if (it->bidi_p && it->bidi_it.first_elt)
  9048     {
  9049       get_visually_first_element (it);
  9050       SET_TEXT_POS (position, IT_STRING_CHARPOS (*it), IT_STRING_BYTEPOS (*it));
  9051     }
  9052 
  9053   /* Time to check for invisible text?  */
  9054   if (IT_STRING_CHARPOS (*it) < it->end_charpos)
  9055     {
  9056       if (IT_STRING_CHARPOS (*it) >= it->stop_charpos)
  9057         {
  9058           if (!(!it->bidi_p
  9059                 || BIDI_AT_BASE_LEVEL (it->bidi_it)
  9060                 || IT_STRING_CHARPOS (*it) == it->stop_charpos))
  9061             {
  9062               /* With bidi non-linear iteration, we could find
  9063                  ourselves far beyond the last computed stop_charpos,
  9064                  with several other stop positions in between that we
  9065                  missed.  Scan them all now, in buffer's logical
  9066                  order, until we find and handle the last stop_charpos
  9067                  that precedes our current position.  */
  9068               handle_stop_backwards (it, it->stop_charpos);
  9069               return GET_NEXT_DISPLAY_ELEMENT (it);
  9070             }
  9071           else
  9072             {
  9073               if (it->bidi_p)
  9074                 {
  9075                   /* Take note of the stop position we just moved
  9076                      across, for when we will move back across it.  */
  9077                   it->prev_stop = it->stop_charpos;
  9078                   /* If we are at base paragraph embedding level, take
  9079                      note of the last stop position seen at this
  9080                      level.  */
  9081                   if (BIDI_AT_BASE_LEVEL (it->bidi_it))
  9082                     it->base_level_stop = it->stop_charpos;
  9083                 }
  9084               handle_stop (it);
  9085 
  9086               /* Since a handler may have changed IT->method, we must
  9087                  recurse here.  */
  9088               return GET_NEXT_DISPLAY_ELEMENT (it);
  9089             }
  9090         }
  9091       else if (it->bidi_p
  9092                /* If we are before prev_stop, we may have overstepped
  9093                   on our way backwards a stop_pos, and if so, we need
  9094                   to handle that stop_pos.  */
  9095                && IT_STRING_CHARPOS (*it) < it->prev_stop
  9096                /* We can sometimes back up for reasons that have nothing
  9097                   to do with bidi reordering.  E.g., compositions.  The
  9098                   code below is only needed when we are above the base
  9099                   embedding level, so test for that explicitly.  */
  9100                && !BIDI_AT_BASE_LEVEL (it->bidi_it))
  9101         {
  9102           /* If we lost track of base_level_stop, we have no better
  9103              place for handle_stop_backwards to start from than string
  9104              beginning.  This happens, e.g., when we were reseated to
  9105              the previous screenful of text by vertical-motion.  */
  9106           if (it->base_level_stop <= 0
  9107               || IT_STRING_CHARPOS (*it) < it->base_level_stop)
  9108             it->base_level_stop = 0;
  9109           handle_stop_backwards (it, it->base_level_stop);
  9110           return GET_NEXT_DISPLAY_ELEMENT (it);
  9111         }
  9112     }
  9113 
  9114   if (it->current.overlay_string_index >= 0)
  9115     {
  9116       /* Get the next character from an overlay string.  In overlay
  9117          strings, there is no field width or padding with spaces to
  9118          do.  */
  9119       if (IT_STRING_CHARPOS (*it) >= SCHARS (it->string))
  9120         {
  9121           it->what = IT_EOB;
  9122           return false;
  9123         }
  9124       else if (CHAR_COMPOSED_P (it, IT_STRING_CHARPOS (*it),
  9125                                 IT_STRING_BYTEPOS (*it),
  9126                                 it->bidi_it.scan_dir < 0
  9127                                 ? -1
  9128                                 : SCHARS (it->string))
  9129                && next_element_from_composition (it))
  9130         {
  9131           return true;
  9132         }
  9133       else if (STRING_MULTIBYTE (it->string))
  9134         {
  9135           const unsigned char *s = (SDATA (it->string)
  9136                                     + IT_STRING_BYTEPOS (*it));
  9137           it->c = check_char_and_length (s, &it->len);
  9138         }
  9139       else
  9140         {
  9141           it->c = SREF (it->string, IT_STRING_BYTEPOS (*it));
  9142           it->len = 1;
  9143         }
  9144     }
  9145   else
  9146     {
  9147       /* Get the next character from a Lisp string that is not an
  9148          overlay string.  Such strings come from the mode line, for
  9149          example.  We may have to pad with spaces, or truncate the
  9150          string.  See also next_element_from_c_string.  */
  9151       if (IT_STRING_CHARPOS (*it) >= it->end_charpos)
  9152         {
  9153           it->what = IT_EOB;
  9154           return false;
  9155         }
  9156       else if (IT_STRING_CHARPOS (*it) >= it->string_nchars)
  9157         {
  9158           /* Pad with spaces.  */
  9159           it->c = ' ', it->len = 1;
  9160           CHARPOS (position) = BYTEPOS (position) = -1;
  9161         }
  9162       else if (CHAR_COMPOSED_P (it, IT_STRING_CHARPOS (*it),
  9163                                 IT_STRING_BYTEPOS (*it),
  9164                                 it->bidi_it.scan_dir < 0
  9165                                 ? -1
  9166                                 : it->string_nchars)
  9167                && next_element_from_composition (it))
  9168         {
  9169           return true;
  9170         }
  9171       else if (STRING_MULTIBYTE (it->string))
  9172         {
  9173           const unsigned char *s = (SDATA (it->string)
  9174                                     + IT_STRING_BYTEPOS (*it));
  9175           it->c = check_char_and_length (s, &it->len);
  9176         }
  9177       else
  9178         {
  9179           it->c = SREF (it->string, IT_STRING_BYTEPOS (*it));
  9180           it->len = 1;
  9181         }
  9182     }
  9183 
  9184   /* Record what we have and where it came from.  */
  9185   it->what = IT_CHARACTER;
  9186   it->object = it->string;
  9187   it->position = position;
  9188   return true;
  9189 }
  9190 
  9191 
  9192 /* Load IT with next display element from C string IT->s.
  9193    IT->string_nchars is the maximum number of characters to return
  9194    from the string.  IT->end_charpos may be greater than
  9195    IT->string_nchars when this function is called, in which case we
  9196    may have to return padding spaces.  Value is false if end of string
  9197    reached, including padding spaces.  */
  9198 
  9199 static bool
  9200 next_element_from_c_string (struct it *it)
  9201 {
  9202   bool success_p = true;
  9203 
  9204   eassert (it->s);
  9205   eassert (!it->bidi_p || it->s == it->bidi_it.string.s);
  9206   it->what = IT_CHARACTER;
  9207   BYTEPOS (it->position) = CHARPOS (it->position) = 0;
  9208   it->object = make_fixnum (0);
  9209 
  9210   /* With bidi reordering, the character to display might not be the
  9211      character at IT_CHARPOS.  BIDI_IT.FIRST_ELT means that
  9212      we were reseated to a new string, whose paragraph direction is
  9213      not known.  */
  9214   if (it->bidi_p && it->bidi_it.first_elt)
  9215     get_visually_first_element (it);
  9216 
  9217   /* IT's position can be greater than IT->string_nchars in case a
  9218      field width or precision has been specified when the iterator was
  9219      initialized.  */
  9220   if (IT_CHARPOS (*it) >= it->end_charpos)
  9221     {
  9222       /* End of the game.  */
  9223       it->what = IT_EOB;
  9224       success_p = false;
  9225     }
  9226   else if (IT_CHARPOS (*it) >= it->string_nchars)
  9227     {
  9228       /* Pad with spaces.  */
  9229       it->c = ' ', it->len = 1;
  9230       BYTEPOS (it->position) = CHARPOS (it->position) = -1;
  9231     }
  9232   else if (it->multibyte_p)
  9233     it->c = check_char_and_length (it->s + IT_BYTEPOS (*it), &it->len);
  9234   else
  9235     it->c = it->s[IT_BYTEPOS (*it)], it->len = 1;
  9236 
  9237   return success_p;
  9238 }
  9239 
  9240 
  9241 /* Set up IT to return characters from an ellipsis, if appropriate.
  9242    The definition of the ellipsis glyphs may come from a display table
  9243    entry.  This function fills IT with the first glyph from the
  9244    ellipsis if an ellipsis is to be displayed.  */
  9245 
  9246 static bool
  9247 next_element_from_ellipsis (struct it *it)
  9248 {
  9249   if (it->selective_display_ellipsis_p)
  9250     setup_for_ellipsis (it, it->len);
  9251   else
  9252     {
  9253       /* The face at the current position may be different from the
  9254          face we find after the invisible text.  Remember what it
  9255          was in IT->saved_face_id, and signal that it's there by
  9256          setting face_before_selective_p.  */
  9257       it->saved_face_id = it->face_id;
  9258       it->method = GET_FROM_BUFFER;
  9259       it->object = it->w->contents;
  9260       reseat_at_next_visible_line_start (it, true);
  9261       it->face_before_selective_p = true;
  9262     }
  9263 
  9264   return GET_NEXT_DISPLAY_ELEMENT (it);
  9265 }
  9266 
  9267 
  9268 /* Deliver an image display element.  The iterator IT is already
  9269    filled with image information (done in handle_display_prop).  Value
  9270    is always true.  */
  9271 
  9272 
  9273 static bool
  9274 next_element_from_image (struct it *it)
  9275 {
  9276   it->what = IT_IMAGE;
  9277   return true;
  9278 }
  9279 
  9280 static bool
  9281 next_element_from_xwidget (struct it *it)
  9282 {
  9283   it->what = IT_XWIDGET;
  9284   return true;
  9285 }
  9286 
  9287 
  9288 /* Fill iterator IT with next display element from a stretch glyph
  9289    property.  IT->object is the value of the text property.  Value is
  9290    always true.  */
  9291 
  9292 static bool
  9293 next_element_from_stretch (struct it *it)
  9294 {
  9295   it->what = IT_STRETCH;
  9296   return true;
  9297 }
  9298 
  9299 /* Scan backwards from IT's current position until we find a stop
  9300    position, or until BEGV.  This is called when we find ourself
  9301    before both the last known prev_stop and base_level_stop while
  9302    reordering bidirectional text.  */
  9303 
  9304 static void
  9305 compute_stop_pos_backwards (struct it *it)
  9306 {
  9307   const int SCAN_BACK_LIMIT = 1000;
  9308   struct text_pos pos;
  9309   struct display_pos save_current = it->current;
  9310   struct text_pos save_position = it->position;
  9311   ptrdiff_t charpos = IT_CHARPOS (*it);
  9312   ptrdiff_t where_we_are = charpos;
  9313   ptrdiff_t save_stop_pos = it->stop_charpos;
  9314   ptrdiff_t save_end_pos = it->end_charpos;
  9315 
  9316   eassert (NILP (it->string) && !it->s);
  9317   eassert (it->bidi_p);
  9318   it->bidi_p = false;
  9319   do
  9320     {
  9321       it->end_charpos = min (charpos + 1, ZV);
  9322       charpos = max (charpos - SCAN_BACK_LIMIT, BEGV);
  9323       SET_TEXT_POS (pos, charpos, CHAR_TO_BYTE (charpos));
  9324       reseat_1 (it, pos, false);
  9325       compute_stop_pos (it);
  9326       /* We must advance forward, right?  */
  9327       if (it->stop_charpos <= charpos)
  9328         emacs_abort ();
  9329     }
  9330   while (charpos > BEGV && it->stop_charpos >= it->end_charpos);
  9331 
  9332   if (it->stop_charpos <= where_we_are)
  9333     it->prev_stop = it->stop_charpos;
  9334   else
  9335     it->prev_stop = BEGV;
  9336   it->bidi_p = true;
  9337   it->current = save_current;
  9338   it->position = save_position;
  9339   it->stop_charpos = save_stop_pos;
  9340   it->end_charpos = save_end_pos;
  9341 }
  9342 
  9343 /* Scan forward from CHARPOS in the current buffer/string, until we
  9344    find a stop position > current IT's position.  Then handle the stop
  9345    position before that.  This is called when we bump into a stop
  9346    position while reordering bidirectional text.  CHARPOS should be
  9347    the last previously processed stop_pos (or BEGV/0, if none were
  9348    processed yet) whose position is less than IT's current
  9349    position.  */
  9350 
  9351 static void
  9352 handle_stop_backwards (struct it *it, ptrdiff_t charpos)
  9353 {
  9354   bool bufp = !STRINGP (it->string);
  9355   ptrdiff_t where_we_are = (bufp ? IT_CHARPOS (*it) : IT_STRING_CHARPOS (*it));
  9356   struct display_pos save_current = it->current;
  9357   struct text_pos save_position = it->position;
  9358   struct composition_it save_cmp_it = it->cmp_it;
  9359   struct text_pos pos1;
  9360   ptrdiff_t next_stop;
  9361 
  9362   /* Scan in strict logical order.  */
  9363   eassert (it->bidi_p);
  9364   it->bidi_p = false;
  9365   do
  9366     {
  9367       it->prev_stop = charpos;
  9368       if (bufp)
  9369         {
  9370           SET_TEXT_POS (pos1, charpos, CHAR_TO_BYTE (charpos));
  9371           reseat_1 (it, pos1, false);
  9372         }
  9373       else
  9374         it->current.string_pos = string_pos (charpos, it->string);
  9375       compute_stop_pos (it);
  9376       /* We must advance forward, right?  */
  9377       if (it->stop_charpos <= it->prev_stop)
  9378         emacs_abort ();
  9379       charpos = it->stop_charpos;
  9380     }
  9381   while (charpos <= where_we_are);
  9382 
  9383   it->bidi_p = true;
  9384   it->current = save_current;
  9385   it->position = save_position;
  9386   it->cmp_it = save_cmp_it;
  9387   next_stop = it->stop_charpos;
  9388   it->stop_charpos = it->prev_stop;
  9389   handle_stop (it);
  9390   it->stop_charpos = next_stop;
  9391 }
  9392 
  9393 /* Load IT with the next display element from current_buffer.  Value
  9394    is false if end of buffer reached.  IT->stop_charpos is the next
  9395    position at which to stop and check for text properties or buffer
  9396    end.  */
  9397 
  9398 static bool
  9399 next_element_from_buffer (struct it *it)
  9400 {
  9401   bool success_p = true;
  9402 
  9403   eassert (IT_CHARPOS (*it) >= BEGV);
  9404   eassert (NILP (it->string) && !it->s);
  9405   eassert (!it->bidi_p
  9406            || (NILP (it->bidi_it.string.lstring)
  9407                && it->bidi_it.string.s == NULL));
  9408 
  9409   /* With bidi reordering, the character to display might not be the
  9410      character at IT_CHARPOS.  BIDI_IT.FIRST_ELT means that
  9411      we were reseat()ed to a new buffer position, which is potentially
  9412      a different paragraph.  */
  9413   if (it->bidi_p && it->bidi_it.first_elt)
  9414     {
  9415       get_visually_first_element (it);
  9416       SET_TEXT_POS (it->position, IT_CHARPOS (*it), IT_BYTEPOS (*it));
  9417     }
  9418 
  9419   if (IT_CHARPOS (*it) >= it->stop_charpos)
  9420     {
  9421       if (IT_CHARPOS (*it) >= it->end_charpos)
  9422         {
  9423           bool overlay_strings_follow_p;
  9424 
  9425           /* End of the game, except when overlay strings follow that
  9426              haven't been returned yet.  */
  9427           if (it->overlay_strings_at_end_processed_p)
  9428             overlay_strings_follow_p = false;
  9429           else
  9430             {
  9431               it->overlay_strings_at_end_processed_p = true;
  9432               overlay_strings_follow_p = get_overlay_strings (it, 0);
  9433             }
  9434 
  9435           if (overlay_strings_follow_p)
  9436             success_p = GET_NEXT_DISPLAY_ELEMENT (it);
  9437           else
  9438             {
  9439               it->what = IT_EOB;
  9440               it->position = it->current.pos;
  9441               success_p = false;
  9442             }
  9443         }
  9444       else if (!(!it->bidi_p
  9445                  || BIDI_AT_BASE_LEVEL (it->bidi_it)
  9446                  || IT_CHARPOS (*it) == it->stop_charpos))
  9447         {
  9448           /* With bidi non-linear iteration, we could find ourselves
  9449              far beyond the last computed stop_charpos, with several
  9450              other stop positions in between that we missed.  Scan
  9451              them all now, in buffer's logical order, until we find
  9452              and handle the last stop_charpos that precedes our
  9453              current position.  */
  9454           handle_stop_backwards (it, it->stop_charpos);
  9455           it->ignore_overlay_strings_at_pos_p = false;
  9456           return GET_NEXT_DISPLAY_ELEMENT (it);
  9457         }
  9458       else
  9459         {
  9460           if (it->bidi_p)
  9461             {
  9462               /* Take note of the stop position we just moved across,
  9463                  for when we will move back across it.  */
  9464               it->prev_stop = it->stop_charpos;
  9465               /* If we are at base paragraph embedding level, take
  9466                  note of the last stop position seen at this
  9467                  level.  */
  9468               if (BIDI_AT_BASE_LEVEL (it->bidi_it))
  9469                 it->base_level_stop = it->stop_charpos;
  9470             }
  9471           handle_stop (it);
  9472           it->ignore_overlay_strings_at_pos_p = false;
  9473           return GET_NEXT_DISPLAY_ELEMENT (it);
  9474         }
  9475     }
  9476   else if (it->bidi_p
  9477            /* If we are before prev_stop, we may have overstepped on
  9478               our way backwards a stop_pos, and if so, we need to
  9479               handle that stop_pos.  */
  9480            && IT_CHARPOS (*it) < it->prev_stop
  9481            /* We can sometimes back up for reasons that have nothing
  9482               to do with bidi reordering.  E.g., compositions.  The
  9483               code below is only needed when we are above the base
  9484               embedding level, so test for that explicitly.  */
  9485            && !BIDI_AT_BASE_LEVEL (it->bidi_it))
  9486     {
  9487       if (it->base_level_stop <= 0
  9488           || IT_CHARPOS (*it) < it->base_level_stop)
  9489         {
  9490           /* If we lost track of base_level_stop, we need to find
  9491              prev_stop by looking backwards.  This happens, e.g., when
  9492              we were reseated to the previous screenful of text by
  9493              vertical-motion.  */
  9494           it->base_level_stop = BEGV;
  9495           compute_stop_pos_backwards (it);
  9496           handle_stop_backwards (it, it->prev_stop);
  9497         }
  9498       else
  9499         handle_stop_backwards (it, it->base_level_stop);
  9500       it->ignore_overlay_strings_at_pos_p = false;
  9501       return GET_NEXT_DISPLAY_ELEMENT (it);
  9502     }
  9503   else
  9504     {
  9505       /* No face changes, overlays etc. in sight, so just return a
  9506          character from current_buffer.  */
  9507       unsigned char *p;
  9508       ptrdiff_t stop;
  9509 
  9510       /* We moved to the next buffer position, so any info about
  9511          previously seen overlays is no longer valid.  */
  9512       it->ignore_overlay_strings_at_pos_p = false;
  9513 
  9514       if (composition_break_at_point
  9515           && !NILP (BVAR (current_buffer, enable_multibyte_characters))
  9516           && !NILP (Vauto_composition_mode))
  9517         {
  9518           /* Limit search for composable characters to point's position.  */
  9519           if (it->bidi_it.scan_dir < 0)
  9520             stop = (PT <= IT_CHARPOS (*it)) ? PT : -1;
  9521           else
  9522             stop = (IT_CHARPOS (*it) < PT
  9523                     && PT < it->end_charpos) ? PT : it->end_charpos;
  9524         }
  9525       else
  9526         stop = it->bidi_it.scan_dir < 0 ? -1 : it->end_charpos;
  9527       if (CHAR_COMPOSED_P (it, IT_CHARPOS (*it), IT_BYTEPOS (*it),
  9528                            stop)
  9529           && next_element_from_composition (it))
  9530         {
  9531           return true;
  9532         }
  9533 
  9534       /* Get the next character, maybe multibyte.  */
  9535       p = BYTE_POS_ADDR (IT_BYTEPOS (*it));
  9536       if (it->multibyte_p && !ASCII_CHAR_P (*p))
  9537         it->c = string_char_and_length (p, &it->len);
  9538       else
  9539         it->c = *p, it->len = 1;
  9540 
  9541       /* Record what we have and where it came from.  */
  9542       it->what = IT_CHARACTER;
  9543       it->object = it->w->contents;
  9544       it->position = it->current.pos;
  9545 
  9546       /* Normally we return the character found above, except when we
  9547          really want to return an ellipsis for selective display.  */
  9548       if (it->selective)
  9549         {
  9550           if (it->c == '\n')
  9551             {
  9552               /* A value of selective > 0 means hide lines indented more
  9553                  than that number of columns.  */
  9554               if (it->selective > 0
  9555                   && IT_CHARPOS (*it) + 1 < ZV
  9556                   && indented_beyond_p (IT_CHARPOS (*it) + 1,
  9557                                         IT_BYTEPOS (*it) + 1,
  9558                                         it->selective))
  9559                 {
  9560                   success_p = next_element_from_ellipsis (it);
  9561                   it->dpvec_char_len = -1;
  9562                 }
  9563             }
  9564           else if (it->c == '\r' && it->selective == -1)
  9565             {
  9566               /* A value of selective == -1 means that everything from the
  9567                  CR to the end of the line is invisible, with maybe an
  9568                  ellipsis displayed for it.  */
  9569               success_p = next_element_from_ellipsis (it);
  9570               it->dpvec_char_len = -1;
  9571             }
  9572         }
  9573     }
  9574 
  9575   /* Value is false if end of buffer reached.  */
  9576   eassert (!success_p || it->what != IT_CHARACTER || it->len > 0);
  9577   return success_p;
  9578 }
  9579 
  9580 
  9581 /* Deliver a composition display element.  Unlike the other
  9582    next_element_from_XXX, this function is not registered in the array
  9583    get_next_element[].  It is called from next_element_from_buffer and
  9584    next_element_from_string when necessary.  */
  9585 
  9586 static bool
  9587 next_element_from_composition (struct it *it)
  9588 {
  9589   it->what = IT_COMPOSITION;
  9590   it->len = it->cmp_it.nbytes;
  9591   if (STRINGP (it->string))
  9592     {
  9593       if (it->c < 0)
  9594         {
  9595           IT_STRING_CHARPOS (*it) += it->cmp_it.nchars;
  9596           IT_STRING_BYTEPOS (*it) += it->cmp_it.nbytes;
  9597           return false;
  9598         }
  9599       it->position = it->current.string_pos;
  9600       it->object = it->string;
  9601       it->c = composition_update_it (&it->cmp_it, IT_STRING_CHARPOS (*it),
  9602                                      IT_STRING_BYTEPOS (*it), it->string);
  9603     }
  9604   else
  9605     {
  9606       if (it->c < 0)
  9607         {
  9608           IT_CHARPOS (*it) += it->cmp_it.nchars;
  9609           IT_BYTEPOS (*it) += it->cmp_it.nbytes;
  9610           if (it->bidi_p)
  9611             {
  9612               if (it->bidi_it.new_paragraph)
  9613                 bidi_paragraph_init (it->paragraph_embedding, &it->bidi_it,
  9614                                      false);
  9615               /* Resync the bidi iterator with IT's new position.
  9616                  FIXME: this doesn't support bidirectional text.  */
  9617               while (it->bidi_it.charpos < IT_CHARPOS (*it))
  9618                 bidi_move_to_visually_next (&it->bidi_it);
  9619             }
  9620           return false;
  9621         }
  9622       it->position = it->current.pos;
  9623       it->object = it->w->contents;
  9624       it->c = composition_update_it (&it->cmp_it, IT_CHARPOS (*it),
  9625                                      IT_BYTEPOS (*it), Qnil);
  9626     }
  9627   return true;
  9628 }
  9629 
  9630 
  9631 
  9632 /***********************************************************************
  9633              Moving an iterator without producing glyphs
  9634  ***********************************************************************/
  9635 
  9636 /* Check if iterator is at a position corresponding to a valid buffer
  9637    position after some move_it_ call.  */
  9638 
  9639 #define IT_POS_VALID_AFTER_MOVE_P(it)                   \
  9640   ((it)->method != GET_FROM_STRING || IT_STRING_CHARPOS (*it) == 0)
  9641 
  9642 
  9643 /* Move iterator IT to a specified buffer or X position within one
  9644    line on the display without producing glyphs.
  9645 
  9646    OP should be a bit mask including some or all of these bits:
  9647     MOVE_TO_X: Stop upon reaching x-position TO_X.
  9648     MOVE_TO_POS: Stop upon reaching buffer or string position TO_CHARPOS.
  9649    Regardless of OP's value, stop upon reaching the end of the display line.
  9650 
  9651    TO_X is normally a value 0 <= TO_X <= IT->last_visible_x.
  9652    This means, in particular, that TO_X includes window's horizontal
  9653    scroll amount.
  9654 
  9655    The return value has several possible values that
  9656    say what condition caused the scan to stop:
  9657 
  9658    MOVE_POS_MATCH_OR_ZV
  9659      - when TO_POS or ZV was reached.
  9660 
  9661    MOVE_X_REACHED
  9662      -when TO_X was reached before TO_POS or ZV were reached.
  9663 
  9664    MOVE_LINE_CONTINUED
  9665      - when we reached the end of the display area and the line must
  9666      be continued.
  9667 
  9668    MOVE_LINE_TRUNCATED
  9669      - when we reached the end of the display area and the line is
  9670      truncated.
  9671 
  9672    MOVE_NEWLINE_OR_CR
  9673      - when we stopped at a line end, i.e. a newline or a CR and selective
  9674      display is on.  */
  9675 
  9676 static enum move_it_result
  9677 move_it_in_display_line_to (struct it *it,
  9678                             ptrdiff_t to_charpos, int to_x,
  9679                             enum move_operation_enum op)
  9680 {
  9681   enum move_it_result result = MOVE_UNDEFINED;
  9682   struct glyph_row *saved_glyph_row;
  9683   struct it wrap_it, atpos_it, atx_it, ppos_it;
  9684   void *wrap_data = NULL, *atpos_data = NULL, *atx_data = NULL;
  9685   void *ppos_data = NULL;
  9686   bool may_wrap = false;
  9687   enum it_method prev_method = it->method;
  9688   ptrdiff_t closest_pos UNINIT;
  9689   ptrdiff_t prev_pos = IT_CHARPOS (*it);
  9690   bool saw_smaller_pos = prev_pos < to_charpos;
  9691   bool line_number_pending = false;
  9692 
  9693   /* Don't produce glyphs in produce_glyphs.  */
  9694   saved_glyph_row = it->glyph_row;
  9695   it->glyph_row = NULL;
  9696 
  9697   /* Use wrap_it to save a copy of IT wherever a word wrap could
  9698      occur.  Use atpos_it to save a copy of IT at the desired buffer
  9699      position, if found, so that we can scan ahead and check if the
  9700      word later overshoots the window edge.  Use atx_it similarly, for
  9701      pixel positions.  */
  9702   wrap_it.sp = -1;
  9703   atpos_it.sp = -1;
  9704   atx_it.sp = -1;
  9705 
  9706   /* Use ppos_it under bidi reordering to save a copy of IT for the
  9707      initial position.  We restore that position in IT when we have
  9708      scanned the entire display line without finding a match for
  9709      TO_CHARPOS and all the character positions are greater than
  9710      TO_CHARPOS.  We then restart the scan from the initial position,
  9711      and stop at CLOSEST_POS, which is a position > TO_CHARPOS that is
  9712      the closest to TO_CHARPOS.  */
  9713   if (it->bidi_p)
  9714     {
  9715       if ((op & MOVE_TO_POS) && IT_CHARPOS (*it) >= to_charpos)
  9716         {
  9717           SAVE_IT (ppos_it, *it, ppos_data);
  9718           closest_pos = IT_CHARPOS (*it);
  9719         }
  9720       else
  9721         closest_pos = ZV;
  9722     }
  9723 
  9724 #define BUFFER_POS_REACHED_P()                                  \
  9725   ((op & MOVE_TO_POS) != 0                                      \
  9726    && BUFFERP (it->object)                                      \
  9727    && (IT_CHARPOS (*it) == to_charpos                           \
  9728        || ((!it->bidi_p                                         \
  9729             || BIDI_AT_BASE_LEVEL (it->bidi_it))                \
  9730            && IT_CHARPOS (*it) > to_charpos)                    \
  9731        || (it->what == IT_COMPOSITION                           \
  9732            && ((IT_CHARPOS (*it) > to_charpos                   \
  9733                 && to_charpos >= it->cmp_it.charpos)            \
  9734                || (IT_CHARPOS (*it) < to_charpos                \
  9735                    && to_charpos <= it->cmp_it.charpos))))      \
  9736    && (it->method == GET_FROM_BUFFER                            \
  9737        || (it->method == GET_FROM_DISPLAY_VECTOR                \
  9738            && it->dpvec + it->current.dpvec_index + 1 >= it->dpend)))
  9739 
  9740   if (it->hpos == 0)
  9741     {
  9742       /* If line numbers are being displayed, produce a line number.
  9743          But don't do that if we are to reach first_visible_x, because
  9744          line numbers are not relevant to stuff that is not visible on
  9745          display.  */
  9746       if (!((op && MOVE_TO_X) && to_x == it->first_visible_x)
  9747           && should_produce_line_number (it))
  9748         {
  9749           if (it->current_x == it->first_visible_x)
  9750             maybe_produce_line_number (it);
  9751           else
  9752             line_number_pending = true;
  9753         }
  9754       /* If there's a line-/wrap-prefix, handle it, if we didn't already.  */
  9755       if (it->area == TEXT_AREA && !it->string_from_prefix_prop_p)
  9756         handle_line_prefix (it);
  9757     }
  9758 
  9759   if (IT_CHARPOS (*it) < CHARPOS (this_line_min_pos))
  9760     SET_TEXT_POS (this_line_min_pos, IT_CHARPOS (*it), IT_BYTEPOS (*it));
  9761 
  9762   while (true)
  9763     {
  9764       int x, i, ascent = 0, descent = 0;
  9765 
  9766 /* Utility macro to reset an iterator with x, ascent, and descent.  */
  9767 #define IT_RESET_X_ASCENT_DESCENT(IT)                   \
  9768   ((IT)->current_x = x, (IT)->max_ascent = ascent,      \
  9769    (IT)->max_descent = descent)
  9770 
  9771       /* Stop if we move beyond TO_CHARPOS (after an image or a
  9772          display string or stretch glyph).  */
  9773       if ((op & MOVE_TO_POS) != 0
  9774           && BUFFERP (it->object)
  9775           && it->method == GET_FROM_BUFFER
  9776           && (((!it->bidi_p
  9777                 /* When the iterator is at base embedding level, we
  9778                    are guaranteed that characters are delivered for
  9779                    display in strictly increasing order of their
  9780                    buffer positions.  */
  9781                 || BIDI_AT_BASE_LEVEL (it->bidi_it))
  9782                && IT_CHARPOS (*it) > to_charpos)
  9783               || (it->bidi_p
  9784                   && (prev_method == GET_FROM_IMAGE
  9785                       || prev_method == GET_FROM_STRETCH
  9786                       || prev_method == GET_FROM_STRING)
  9787                   /* Passed TO_CHARPOS from left to right.  */
  9788                   && ((prev_pos < to_charpos
  9789                        && IT_CHARPOS (*it) >= to_charpos)
  9790                       /* Passed TO_CHARPOS from right to left.  */
  9791                       || (prev_pos > to_charpos
  9792                           && IT_CHARPOS (*it) <= to_charpos)))))
  9793         {
  9794           if (it->line_wrap != WORD_WRAP || wrap_it.sp < 0)
  9795             {
  9796               result = MOVE_POS_MATCH_OR_ZV;
  9797               break;
  9798             }
  9799           else if (it->line_wrap == WORD_WRAP && atpos_it.sp < 0)
  9800             /* If wrap_it is valid, the current position might be in a
  9801                word that is wrapped.  So, save the iterator in
  9802                atpos_it and continue to see if wrapping happens.  */
  9803             SAVE_IT (atpos_it, *it, atpos_data);
  9804         }
  9805 
  9806       /* Stop when ZV reached.
  9807          We used to stop here when TO_CHARPOS reached as well, but that is
  9808          too soon if this glyph does not fit on this line.  So we handle it
  9809          explicitly below.  */
  9810       if (!get_next_display_element (it))
  9811         {
  9812           result = MOVE_POS_MATCH_OR_ZV;
  9813           break;
  9814         }
  9815 
  9816       if (it->line_wrap == TRUNCATE)
  9817         {
  9818           /* If it->pixel_width is zero, the last PRODUCE_GLYPHS call
  9819              produced something that doesn't consume any screen estate
  9820              in the text area, so we don't want to exit the loop at
  9821              TO_CHARPOS, before we produce the glyph for that buffer
  9822              position.  This happens, e.g., when there's an overlay at
  9823              TO_CHARPOS that draws a fringe bitmap.  */
  9824           if (BUFFER_POS_REACHED_P ()
  9825               && (it->pixel_width > 0
  9826                   || IT_CHARPOS (*it) > to_charpos
  9827                   || it->area != TEXT_AREA))
  9828             {
  9829               result = MOVE_POS_MATCH_OR_ZV;
  9830               break;
  9831             }
  9832         }
  9833       else
  9834         {
  9835           if (it->line_wrap == WORD_WRAP && it->area == TEXT_AREA)
  9836             {
  9837               bool next_may_wrap = may_wrap;
  9838               /* Can we wrap after this character?  */
  9839               if (char_can_wrap_after (it))
  9840                 next_may_wrap = true;
  9841               else
  9842                 next_may_wrap = false;
  9843               /* Can we wrap here? */
  9844               if (may_wrap && char_can_wrap_before (it))
  9845                 {
  9846                   /* We have reached a glyph that follows one or more
  9847                      whitespace characters or characters that allow
  9848                      wrapping after them.  If this character allows
  9849                      wrapping before it, save this position as a
  9850                      wrapping point.  */
  9851                   if (atpos_it.sp >= 0)
  9852                     {
  9853                       RESTORE_IT (it, &atpos_it, atpos_data);
  9854                       result = MOVE_POS_MATCH_OR_ZV;
  9855                       goto done;
  9856                     }
  9857                   if (atx_it.sp >= 0)
  9858                     {
  9859                       RESTORE_IT (it, &atx_it, atx_data);
  9860                       result = MOVE_X_REACHED;
  9861                       goto done;
  9862                     }
  9863                   /* Otherwise, we can wrap here.  */
  9864                   SAVE_IT (wrap_it, *it, wrap_data);
  9865                 }
  9866               /* Update may_wrap for the next iteration.  */
  9867               may_wrap = next_may_wrap;
  9868             }
  9869         }
  9870 
  9871       /* Remember the line height for the current line, in case
  9872          the next element doesn't fit on the line.  */
  9873       ascent = it->max_ascent;
  9874       descent = it->max_descent;
  9875 
  9876       /* The call to produce_glyphs will get the metrics of the
  9877          display element IT is loaded with.  Record the x-position
  9878          before this display element, in case it doesn't fit on the
  9879          line.  */
  9880       x = it->current_x;
  9881 
  9882       PRODUCE_GLYPHS (it);
  9883 
  9884       if (it->area != TEXT_AREA)
  9885         {
  9886           prev_method = it->method;
  9887           if (it->method == GET_FROM_BUFFER)
  9888             prev_pos = IT_CHARPOS (*it);
  9889           set_iterator_to_next (it, true);
  9890           if (IT_CHARPOS (*it) < CHARPOS (this_line_min_pos))
  9891             SET_TEXT_POS (this_line_min_pos,
  9892                           IT_CHARPOS (*it), IT_BYTEPOS (*it));
  9893           if (it->bidi_p
  9894               && (op & MOVE_TO_POS)
  9895               && IT_CHARPOS (*it) > to_charpos
  9896               && IT_CHARPOS (*it) < closest_pos)
  9897             closest_pos = IT_CHARPOS (*it);
  9898           continue;
  9899         }
  9900 
  9901       /* The number of glyphs we get back in IT->nglyphs will normally
  9902          be 1 except when IT->c is (i) a TAB, or (ii) a multi-glyph
  9903          character on a terminal frame, or (iii) a line end.  For the
  9904          second case, IT->nglyphs - 1 padding glyphs will be present.
  9905          (On X frames, there is only one glyph produced for a
  9906          composite character.)
  9907 
  9908          The behavior implemented below means, for continuation lines,
  9909          that as many spaces of a TAB as fit on the current line are
  9910          displayed there.  For terminal frames, as many glyphs of a
  9911          multi-glyph character are displayed in the current line, too.
  9912          This is what the old redisplay code did, and we keep it that
  9913          way.  Under X, the whole shape of a complex character must
  9914          fit on the line or it will be completely displayed in the
  9915          next line.
  9916 
  9917          Note that both for tabs and padding glyphs, all glyphs have
  9918          the same width.  */
  9919       if (it->nglyphs)
  9920         {
  9921           /* More than one glyph or glyph doesn't fit on line.  All
  9922              glyphs have the same width.  */
  9923           int single_glyph_width = it->pixel_width / it->nglyphs;
  9924           int new_x;
  9925           int x_before_this_char = x;
  9926           int hpos_before_this_char = it->hpos;
  9927 
  9928           for (i = 0; i < it->nglyphs; ++i, x = new_x)
  9929             {
  9930               new_x = x + single_glyph_width;
  9931 
  9932               /* We want to leave anything reaching TO_X to the caller.  */
  9933               if ((op & MOVE_TO_X) && new_x > to_x)
  9934                 {
  9935                   if (BUFFER_POS_REACHED_P ())
  9936                     {
  9937                       if (it->line_wrap != WORD_WRAP || wrap_it.sp < 0)
  9938                         goto buffer_pos_reached;
  9939                       if (atpos_it.sp < 0)
  9940                         {
  9941                           SAVE_IT (atpos_it, *it, atpos_data);
  9942                           IT_RESET_X_ASCENT_DESCENT (&atpos_it);
  9943                         }
  9944                     }
  9945                   else
  9946                     {
  9947                       if (it->line_wrap != WORD_WRAP || wrap_it.sp < 0)
  9948                         {
  9949                           it->current_x = x;
  9950                           result = MOVE_X_REACHED;
  9951                           break;
  9952                         }
  9953                       if (atx_it.sp < 0)
  9954                         {
  9955                           SAVE_IT (atx_it, *it, atx_data);
  9956                           IT_RESET_X_ASCENT_DESCENT (&atx_it);
  9957                         }
  9958                     }
  9959                 }
  9960 
  9961               if (/* Lines are continued.  */
  9962                   it->line_wrap != TRUNCATE
  9963                   && (/* And glyph doesn't fit on the line.  */
  9964                       new_x > it->last_visible_x
  9965                       /* Or it fits exactly and we're on a window
  9966                          system frame.  */
  9967                       || (new_x == it->last_visible_x
  9968                           && FRAME_WINDOW_P (it->f)
  9969                           && ((it->bidi_p && it->bidi_it.paragraph_dir == R2L)
  9970                               ? WINDOW_LEFT_FRINGE_WIDTH (it->w)
  9971                               : WINDOW_RIGHT_FRINGE_WIDTH (it->w)))))
  9972                 {
  9973                   bool moved_forward = false;
  9974 
  9975                   if (/* IT->hpos == 0 means the very first glyph
  9976                          doesn't fit on the line, e.g. a wide image.  */
  9977                       it->hpos == 0
  9978                       || (new_x == it->last_visible_x
  9979                           && FRAME_WINDOW_P (it->f)))
  9980                     {
  9981                       ++it->hpos;
  9982                       it->current_x = new_x;
  9983 
  9984                       /* The character's last glyph just barely fits
  9985                          in this row.  */
  9986                       if (i == it->nglyphs - 1)
  9987                         {
  9988                           /* If this is the destination position,
  9989                              return a position *before* it in this row,
  9990                              now that we know it fits in this row.  */
  9991                           if (BUFFER_POS_REACHED_P ())
  9992                             {
  9993                               bool can_wrap = true;
  9994 
  9995                               /* If the previous character says we can
  9996                                  wrap after it, but the current
  9997                                  character says we can't wrap before
  9998                                  it, then we can't wrap here.  */
  9999                               if (it->line_wrap == WORD_WRAP
 10000                                   && wrap_it.sp >= 0
 10001                                   && may_wrap
 10002                                   && IT_OVERFLOW_NEWLINE_INTO_FRINGE (it))
 10003                                 {
 10004                                   struct it tem_it;
 10005                                   void *tem_data = NULL;
 10006 
 10007                                   SAVE_IT (tem_it, *it, tem_data);
 10008                                   set_iterator_to_next (it, true);
 10009                                   if (get_next_display_element (it)
 10010                                       && !char_can_wrap_before (it))
 10011                                     can_wrap = false;
 10012                                   RESTORE_IT (it, &tem_it, tem_data);
 10013                                 }
 10014                               if (it->line_wrap != WORD_WRAP
 10015                                   || wrap_it.sp < 0
 10016                                   /* If we've just found whitespace
 10017                                      where we can wrap, effectively
 10018                                      ignore the previous wrap point --
 10019                                      it is no longer relevant, but we
 10020                                      won't have an opportunity to
 10021                                      update it, since we've reached
 10022                                      the edge of this screen line.  */
 10023                                   || (may_wrap && can_wrap
 10024                                       && IT_OVERFLOW_NEWLINE_INTO_FRINGE (it)))
 10025                                 {
 10026                                   it->hpos = hpos_before_this_char;
 10027                                   it->current_x = x_before_this_char;
 10028                                   result = MOVE_POS_MATCH_OR_ZV;
 10029                                   break;
 10030                                 }
 10031                               if (it->line_wrap == WORD_WRAP
 10032                                   && atpos_it.sp < 0)
 10033                                 {
 10034                                   SAVE_IT (atpos_it, *it, atpos_data);
 10035                                   atpos_it.current_x = x_before_this_char;
 10036                                   atpos_it.hpos = hpos_before_this_char;
 10037                                 }
 10038                             }
 10039 
 10040                           prev_method = it->method;
 10041                           if (it->method == GET_FROM_BUFFER)
 10042                             prev_pos = IT_CHARPOS (*it);
 10043                           set_iterator_to_next (it, true);
 10044                           if (IT_CHARPOS (*it) < CHARPOS (this_line_min_pos))
 10045                             SET_TEXT_POS (this_line_min_pos,
 10046                                           IT_CHARPOS (*it), IT_BYTEPOS (*it));
 10047                           /* On graphical terminals, newlines may
 10048                              "overflow" into the fringe if
 10049                              overflow-newline-into-fringe is non-nil.
 10050                              On text terminals, and on graphical
 10051                              terminals with no right margin, newlines
 10052                              may overflow into the last glyph on the
 10053                              display line.*/
 10054                           if (!FRAME_WINDOW_P (it->f)
 10055                               || ((it->bidi_p
 10056                                    && it->bidi_it.paragraph_dir == R2L)
 10057                                   ? WINDOW_LEFT_FRINGE_WIDTH (it->w)
 10058                                   : WINDOW_RIGHT_FRINGE_WIDTH (it->w)) == 0
 10059                               || IT_OVERFLOW_NEWLINE_INTO_FRINGE (it))
 10060                             {
 10061                               if (!get_next_display_element (it))
 10062                                 {
 10063                                   result = MOVE_POS_MATCH_OR_ZV;
 10064                                   break;
 10065                                 }
 10066                               moved_forward = true;
 10067                               if (BUFFER_POS_REACHED_P ())
 10068                                 {
 10069                                   if (ITERATOR_AT_END_OF_LINE_P (it))
 10070                                     result = MOVE_POS_MATCH_OR_ZV;
 10071                                   else
 10072                                     result = MOVE_LINE_CONTINUED;
 10073                                   break;
 10074                                 }
 10075                               if (ITERATOR_AT_END_OF_LINE_P (it)
 10076                                   && (it->line_wrap != WORD_WRAP
 10077                                       || wrap_it.sp < 0
 10078                                       || IT_OVERFLOW_NEWLINE_INTO_FRINGE (it)))
 10079                                 {
 10080                                   result = MOVE_NEWLINE_OR_CR;
 10081                                   break;
 10082                                 }
 10083                             }
 10084                         }
 10085                     }
 10086                   else
 10087                     IT_RESET_X_ASCENT_DESCENT (it);
 10088 
 10089                   /* If the screen line ends with whitespace (or
 10090                      wrap-able character), and we are under word-wrap,
 10091                      don't use wrap_it: it is no longer relevant, but
 10092                      we won't have an opportunity to update it, since
 10093                      we are done with this screen line.  */
 10094                   if (may_wrap && IT_OVERFLOW_NEWLINE_INTO_FRINGE (it)
 10095                       /* If the character after the one which set the
 10096                          may_wrap flag says we can't wrap before it,
 10097                          we can't wrap here.  Therefore, wrap_it
 10098                          (previously found wrap-point) _is_ relevant
 10099                          in that case.  */
 10100                       && (!moved_forward || char_can_wrap_before (it)))
 10101                     {
 10102                       /* If we've found TO_X, go back there, as we now
 10103                          know the last word fits on this screen line.  */
 10104                       if ((op & MOVE_TO_X) && new_x == it->last_visible_x
 10105                           && atx_it.sp >= 0)
 10106                         {
 10107                           RESTORE_IT (it, &atx_it, atx_data);
 10108                           atpos_it.sp = -1;
 10109                           atx_it.sp = -1;
 10110                           result = MOVE_X_REACHED;
 10111                           break;
 10112                         }
 10113                     }
 10114                   else if (wrap_it.sp >= 0)
 10115                     {
 10116                       RESTORE_IT (it, &wrap_it, wrap_data);
 10117                       atpos_it.sp = -1;
 10118                       atx_it.sp = -1;
 10119                     }
 10120 
 10121                   move_trace ("move_it_in: continued at %td\n",
 10122                               IT_CHARPOS (*it));
 10123                   result = MOVE_LINE_CONTINUED;
 10124                   break;
 10125                 }
 10126 
 10127               if (BUFFER_POS_REACHED_P ())
 10128                 {
 10129                   if (it->line_wrap != WORD_WRAP || wrap_it.sp < 0)
 10130                     goto buffer_pos_reached;
 10131                   if (it->line_wrap == WORD_WRAP && atpos_it.sp < 0)
 10132                     {
 10133                       SAVE_IT (atpos_it, *it, atpos_data);
 10134                       IT_RESET_X_ASCENT_DESCENT (&atpos_it);
 10135                     }
 10136                 }
 10137 
 10138               if (new_x > it->first_visible_x)
 10139                 {
 10140                   /* If we have reached the visible portion of the
 10141                      screen line, produce the line number if needed.  */
 10142                   if (line_number_pending)
 10143                     {
 10144                       line_number_pending = false;
 10145                       it->current_x = it->first_visible_x;
 10146                       maybe_produce_line_number (it);
 10147                       it->current_x += new_x - it->first_visible_x;
 10148                     }
 10149                   /* Glyph is visible.  Increment number of glyphs that
 10150                      would be displayed.  */
 10151                   ++it->hpos;
 10152                 }
 10153             }
 10154 
 10155           if (result != MOVE_UNDEFINED)
 10156             break;
 10157         }
 10158       else if (BUFFER_POS_REACHED_P ())
 10159         {
 10160         buffer_pos_reached:
 10161           IT_RESET_X_ASCENT_DESCENT (it);
 10162           result = MOVE_POS_MATCH_OR_ZV;
 10163           break;
 10164         }
 10165       else if ((op & MOVE_TO_X) && it->current_x >= to_x)
 10166         {
 10167           /* Stop when TO_X specified and reached.  This check is
 10168              necessary here because of lines consisting of a line end,
 10169              only.  The line end will not produce any glyphs and we
 10170              would never get MOVE_X_REACHED.  */
 10171           eassert (it->nglyphs == 0);
 10172           result = MOVE_X_REACHED;
 10173           break;
 10174         }
 10175 
 10176       /* Is this a line end?  If yes, we're done.  */
 10177       if (ITERATOR_AT_END_OF_LINE_P (it))
 10178         {
 10179           /* If we are past TO_CHARPOS, but never saw any character
 10180              positions smaller than TO_CHARPOS, return
 10181              MOVE_POS_MATCH_OR_ZV, like the unidirectional display
 10182              did.  */
 10183           if (it->bidi_p && (op & MOVE_TO_POS) != 0)
 10184             {
 10185               if (!saw_smaller_pos && IT_CHARPOS (*it) > to_charpos)
 10186                 {
 10187                   if (closest_pos < ZV)
 10188                     {
 10189                       RESTORE_IT (it, &ppos_it, ppos_data);
 10190                       /* Don't recurse if closest_pos is equal to
 10191                          to_charpos, since we have just tried that.  */
 10192                       if (closest_pos != to_charpos)
 10193                         move_it_in_display_line_to (it, closest_pos, -1,
 10194                                                     MOVE_TO_POS);
 10195                       result = MOVE_POS_MATCH_OR_ZV;
 10196                     }
 10197                   else
 10198                     goto buffer_pos_reached;
 10199                 }
 10200               else if (it->line_wrap == WORD_WRAP && atpos_it.sp >= 0
 10201                        && IT_CHARPOS (*it) > to_charpos)
 10202                 goto buffer_pos_reached;
 10203               else
 10204                 result = MOVE_NEWLINE_OR_CR;
 10205             }
 10206           else
 10207             result = MOVE_NEWLINE_OR_CR;
 10208           /* If lines are truncated, and the line we moved across is
 10209              completely hscrolled out of view, reset the line metrics
 10210              to those of the newline we've just processed, so that
 10211              glyphs not on display don't affect the line's height.  */
 10212           if (it->line_wrap == TRUNCATE
 10213               && it->current_x <= it->first_visible_x
 10214               && result == MOVE_NEWLINE_OR_CR
 10215               && it->char_to_display == '\n')
 10216             {
 10217               it->max_ascent = it->ascent;
 10218               it->max_descent = it->descent;
 10219             }
 10220           /* If we've processed the newline, make sure this flag is
 10221              reset, as it must only be set when the newline itself is
 10222              processed.  */
 10223           if (result == MOVE_NEWLINE_OR_CR)
 10224             it->constrain_row_ascent_descent_p = false;
 10225           break;
 10226         }
 10227 
 10228       prev_method = it->method;
 10229       if (it->method == GET_FROM_BUFFER)
 10230         prev_pos = IT_CHARPOS (*it);
 10231 
 10232       /* Detect overly-wide wrap-prefixes made of (space ...) display
 10233          properties.  When such a wrap prefix reaches past the right
 10234          margin of the window, we need to avoid the call to
 10235          set_iterator_to_next below, so that it->line_wrap is left at
 10236          its TRUNCATE value wisely set by handle_line_prefix.
 10237          Otherwise, set_iterator_to_next will pop the iterator stack,
 10238          restore it->line_wrap, and we might miss the opportunity to
 10239          exit the loop and return.  */
 10240       bool overwide_wrap_prefix =
 10241         CONSP (it->object) && EQ (XCAR (it->object), Qspace)
 10242         && it->sp > 0 && it->method == GET_FROM_STRETCH
 10243         && it->current_x >= it->last_visible_x
 10244         && it->continuation_lines_width > 0
 10245         && it->line_wrap == TRUNCATE && it->stack[0].line_wrap != TRUNCATE;
 10246       /* The current display element has been consumed.  Advance
 10247          to the next.  */
 10248       if (!overwide_wrap_prefix)
 10249         set_iterator_to_next (it, true);
 10250       if (IT_CHARPOS (*it) < CHARPOS (this_line_min_pos))
 10251         SET_TEXT_POS (this_line_min_pos, IT_CHARPOS (*it), IT_BYTEPOS (*it));
 10252       if (IT_CHARPOS (*it) < to_charpos)
 10253         saw_smaller_pos = true;
 10254       if (it->bidi_p
 10255           && (op & MOVE_TO_POS)
 10256           && IT_CHARPOS (*it) >= to_charpos
 10257           && IT_CHARPOS (*it) < closest_pos)
 10258         closest_pos = IT_CHARPOS (*it);
 10259 
 10260       /* Stop if lines are truncated and IT's current x-position is
 10261          past the right edge of the window now.  */
 10262       if (it->line_wrap == TRUNCATE
 10263           && it->current_x >= it->last_visible_x)
 10264         {
 10265           if (!FRAME_WINDOW_P (it->f)
 10266               || ((it->bidi_p && it->bidi_it.paragraph_dir == R2L)
 10267                   ? WINDOW_LEFT_FRINGE_WIDTH (it->w)
 10268                   : WINDOW_RIGHT_FRINGE_WIDTH (it->w)) == 0
 10269               || IT_OVERFLOW_NEWLINE_INTO_FRINGE (it))
 10270             {
 10271               bool at_eob_p = false;
 10272 
 10273               if ((at_eob_p = !get_next_display_element (it))
 10274                   || BUFFER_POS_REACHED_P ()
 10275                   /* If we are past TO_CHARPOS, but never saw any
 10276                      character positions smaller than TO_CHARPOS,
 10277                      return MOVE_POS_MATCH_OR_ZV, like the
 10278                      unidirectional display did.  */
 10279                   || (it->bidi_p && (op & MOVE_TO_POS) != 0
 10280                       && !saw_smaller_pos
 10281                       && IT_CHARPOS (*it) > to_charpos))
 10282                 {
 10283                   if (it->bidi_p
 10284                       && !BUFFER_POS_REACHED_P ()
 10285                       && !at_eob_p && closest_pos < ZV)
 10286                     {
 10287                       RESTORE_IT (it, &ppos_it, ppos_data);
 10288                       if (closest_pos != to_charpos)
 10289                         move_it_in_display_line_to (it, closest_pos, -1,
 10290                                                     MOVE_TO_POS);
 10291                     }
 10292                   result = MOVE_POS_MATCH_OR_ZV;
 10293                   break;
 10294                 }
 10295               if (ITERATOR_AT_END_OF_LINE_P (it))
 10296                 {
 10297                   result = MOVE_NEWLINE_OR_CR;
 10298                   break;
 10299                 }
 10300             }
 10301           else if (it->bidi_p && (op & MOVE_TO_POS) != 0
 10302                    && !saw_smaller_pos
 10303                    && IT_CHARPOS (*it) > to_charpos)
 10304             {
 10305               if (closest_pos < ZV)
 10306                 {
 10307                   RESTORE_IT (it, &ppos_it, ppos_data);
 10308                   if (closest_pos != to_charpos)
 10309                     move_it_in_display_line_to (it, closest_pos, -1,
 10310                                                 MOVE_TO_POS);
 10311                 }
 10312               result = MOVE_POS_MATCH_OR_ZV;
 10313               break;
 10314             }
 10315           result = MOVE_LINE_TRUNCATED;
 10316           break;
 10317         }
 10318 #undef IT_RESET_X_ASCENT_DESCENT
 10319     }
 10320 
 10321 #undef BUFFER_POS_REACHED_P
 10322 
 10323   /* If we scanned beyond TO_POS, restore the saved iterator either to
 10324      the wrap point (if found), or to atpos/atx location.  We decide which
 10325      data to use to restore the saved iterator state by their X coordinates,
 10326      since buffer positions might increase non-monotonically with screen
 10327      coordinates due to bidi reordering.  */
 10328   if (result == MOVE_LINE_CONTINUED
 10329       && it->line_wrap == WORD_WRAP
 10330       && wrap_it.sp >= 0
 10331       && ((atpos_it.sp >= 0 && wrap_it.current_x < atpos_it.current_x)
 10332           || (atx_it.sp >= 0 && wrap_it.current_x < atx_it.current_x)))
 10333     RESTORE_IT (it, &wrap_it, wrap_data);
 10334   else if (atpos_it.sp >= 0)
 10335     RESTORE_IT (it, &atpos_it, atpos_data);
 10336   else if (atx_it.sp >= 0)
 10337     RESTORE_IT (it, &atx_it, atx_data);
 10338 
 10339  done:
 10340 
 10341   if (atpos_data)
 10342     bidi_unshelve_cache (atpos_data, true);
 10343   if (atx_data)
 10344     bidi_unshelve_cache (atx_data, true);
 10345   if (wrap_data)
 10346     bidi_unshelve_cache (wrap_data, true);
 10347   if (ppos_data)
 10348     bidi_unshelve_cache (ppos_data, true);
 10349 
 10350   /* Restore the iterator settings altered at the beginning of this
 10351      function.  */
 10352   it->glyph_row = saved_glyph_row;
 10353   return result;
 10354 }
 10355 
 10356 /* For external use.  */
 10357 void
 10358 move_it_in_display_line (struct it *it,
 10359                          ptrdiff_t to_charpos, int to_x,
 10360                          enum move_operation_enum op)
 10361 {
 10362   if (it->line_wrap == WORD_WRAP
 10363       && (op & MOVE_TO_X))
 10364     {
 10365       struct it save_it;
 10366       void *save_data = NULL;
 10367       int skip;
 10368 
 10369       SAVE_IT (save_it, *it, save_data);
 10370       skip = move_it_in_display_line_to (it, to_charpos, to_x, op);
 10371       /* When word-wrap is on, TO_X may lie past the end
 10372          of a wrapped line.  Then it->current is the
 10373          character on the next line, so backtrack to the
 10374          space before the wrap point.  */
 10375       if (skip == MOVE_LINE_CONTINUED)
 10376         {
 10377           int prev_x = max (it->current_x - 1, 0);
 10378           RESTORE_IT (it, &save_it, save_data);
 10379           move_it_in_display_line_to
 10380             (it, -1, prev_x, MOVE_TO_X);
 10381         }
 10382       else
 10383         bidi_unshelve_cache (save_data, true);
 10384     }
 10385   else
 10386     move_it_in_display_line_to (it, to_charpos, to_x, op);
 10387 }
 10388 
 10389 
 10390 /* Move IT forward until it satisfies one or more of the criteria in
 10391    TO_CHARPOS, TO_X, TO_Y, and TO_VPOS.
 10392 
 10393    OP is a bit-mask that specifies where to stop, and in particular,
 10394    which of those four position arguments makes a difference.  See the
 10395    description of enum move_operation_enum.
 10396 
 10397    If TO_CHARPOS is in invisible text, e.g. a truncated part of a
 10398    screen line, this function will set IT to the next position that is
 10399    displayed to the right of TO_CHARPOS on the screen.
 10400 
 10401    Return the maximum pixel length of any line scanned but never more
 10402    than it.last_visible_x.  */
 10403 
 10404 int
 10405 move_it_to (struct it *it, ptrdiff_t to_charpos, int to_x, int to_y, int to_vpos, int op)
 10406 {
 10407   enum move_it_result skip, skip2 = MOVE_X_REACHED;
 10408   int line_height, line_start_x = 0, reached = 0;
 10409   int max_current_x = 0;
 10410   void *backup_data = NULL;
 10411   ptrdiff_t orig_charpos = -1;
 10412   enum it_method orig_method = NUM_IT_METHODS;
 10413 
 10414   for (;;)
 10415     {
 10416       orig_charpos = IT_CHARPOS (*it);
 10417       orig_method = it->method;
 10418       if (op & MOVE_TO_VPOS)
 10419         {
 10420           /* If no TO_CHARPOS and no TO_X specified, stop at the
 10421              start of the line TO_VPOS.  */
 10422           if ((op & (MOVE_TO_X | MOVE_TO_POS)) == 0)
 10423             {
 10424               if (it->vpos == to_vpos)
 10425                 {
 10426                   reached = 1;
 10427                   break;
 10428                 }
 10429               else
 10430                 skip = move_it_in_display_line_to (it, -1, -1, 0);
 10431             }
 10432           else
 10433             {
 10434               /* TO_VPOS >= 0 means stop at TO_X in the line at
 10435                  TO_VPOS, or at TO_POS, whichever comes first.  */
 10436               if (it->vpos == to_vpos)
 10437                 {
 10438                   reached = 2;
 10439                   break;
 10440                 }
 10441 
 10442               skip = move_it_in_display_line_to (it, to_charpos, to_x, op);
 10443 
 10444               if (skip == MOVE_POS_MATCH_OR_ZV || it->vpos == to_vpos)
 10445                 {
 10446                   reached = 3;
 10447                   break;
 10448                 }
 10449               else if (skip == MOVE_X_REACHED && it->vpos != to_vpos)
 10450                 {
 10451                   /* We have reached TO_X but not in the line we want.  */
 10452                   skip = move_it_in_display_line_to (it, to_charpos,
 10453                                                      -1, MOVE_TO_POS);
 10454                   if (skip == MOVE_POS_MATCH_OR_ZV)
 10455                     {
 10456                       reached = 4;
 10457                       break;
 10458                     }
 10459                 }
 10460             }
 10461         }
 10462       else if (op & MOVE_TO_Y)
 10463         {
 10464           struct it it_backup;
 10465 
 10466           if (it->line_wrap == WORD_WRAP)
 10467             SAVE_IT (it_backup, *it, backup_data);
 10468 
 10469           /* TO_Y specified means stop at TO_X in the line containing
 10470              TO_Y---or at TO_CHARPOS if this is reached first.  The
 10471              problem is that we can't really tell whether the line
 10472              contains TO_Y before we have completely scanned it, and
 10473              this may skip past TO_X.  What we do is to first scan to
 10474              TO_X.
 10475 
 10476              If TO_X is not specified, use a TO_X of zero.  The reason
 10477              is to make the outcome of this function more predictable.
 10478              If we didn't use TO_X == 0, we would stop at the end of
 10479              the line which is probably not what a caller would expect
 10480              to happen.  */
 10481           skip = move_it_in_display_line_to
 10482             (it, to_charpos, ((op & MOVE_TO_X) ? to_x : 0),
 10483              (MOVE_TO_X | (op & MOVE_TO_POS)));
 10484 
 10485           /* If TO_CHARPOS is reached or ZV, we don't have to do more.  */
 10486           if (skip == MOVE_POS_MATCH_OR_ZV)
 10487             reached = 5;
 10488           else if (skip == MOVE_X_REACHED)
 10489             {
 10490               /* If TO_X was reached, we want to know whether TO_Y is
 10491                  in the line.  We know this is the case if the already
 10492                  scanned glyphs make the line tall enough.  Otherwise,
 10493                  we must check by scanning the rest of the line.  */
 10494               line_height = it->max_ascent + it->max_descent;
 10495               if (to_y >= it->current_y
 10496                   && to_y < it->current_y + line_height)
 10497                 {
 10498                   reached = 6;
 10499                   break;
 10500                 }
 10501               SAVE_IT (it_backup, *it, backup_data);
 10502               move_trace ("move_it: from %td\n", IT_CHARPOS (*it));
 10503               skip2 = move_it_in_display_line_to (it, to_charpos, -1,
 10504                                                   op & MOVE_TO_POS);
 10505               move_trace ("move_it: to %td\n", IT_CHARPOS (*it));
 10506               line_height = it->max_ascent + it->max_descent;
 10507               move_trace ("move_it: line_height = %d\n", line_height);
 10508 
 10509               if (to_y >= it->current_y
 10510                   && to_y < it->current_y + line_height)
 10511                 {
 10512                   /* If TO_Y is in this line and TO_X was reached
 10513                      above, we scanned too far.  We have to restore
 10514                      IT's settings to the ones before skipping.  But
 10515                      keep the more accurate values of max_ascent and
 10516                      max_descent we've found while skipping the rest
 10517                      of the line, for the sake of callers, such as
 10518                      pos_visible_p, that need to know the line
 10519                      height.  */
 10520                   int max_ascent = it->max_ascent;
 10521                   int max_descent = it->max_descent;
 10522 
 10523                   RESTORE_IT (it, &it_backup, backup_data);
 10524                   it->max_ascent = max_ascent;
 10525                   it->max_descent = max_descent;
 10526                   reached = 6;
 10527                 }
 10528               else
 10529                 {
 10530                   skip = skip2;
 10531                   if (skip == MOVE_POS_MATCH_OR_ZV)
 10532                     {
 10533                       reached = 7;
 10534                       /* If the last move_it_in_display_line_to call
 10535                          took us away from TO_CHARPOS, back up to the
 10536                          previous position, as it is a better
 10537                          approximation of TO_CHARPOS.  (Note that we
 10538                          could have both positions after TO_CHARPOS or
 10539                          both positions before it, due to bidi
 10540                          reordering.)  */
 10541                       if (to_charpos > 0
 10542                           && IT_CHARPOS (*it) != to_charpos
 10543                           && ((IT_CHARPOS (it_backup) > to_charpos)
 10544                               == (IT_CHARPOS (*it) > to_charpos)))
 10545                         {
 10546                           int max_ascent = it->max_ascent;
 10547                           int max_descent = it->max_descent;
 10548 
 10549                           RESTORE_IT (it, &it_backup, backup_data);
 10550                           it->max_ascent = max_ascent;
 10551                           it->max_descent = max_descent;
 10552                         }
 10553                     }
 10554                 }
 10555             }
 10556           else
 10557             {
 10558               /* Check whether TO_Y is in this line.  */
 10559               line_height = it->max_ascent + it->max_descent;
 10560               move_trace ("move_it: line_height = %d\n", line_height);
 10561 
 10562               if (to_y >= it->current_y
 10563                   && to_y < it->current_y + line_height)
 10564                 {
 10565                   if (to_y > it->current_y)
 10566                     max_current_x = max (it->current_x, max_current_x);
 10567 
 10568                   /* When word-wrap is on, TO_X may lie past the end
 10569                      of a wrapped line.  Then it->current is the
 10570                      character on the next line, so backtrack to the
 10571                      space before the wrap point.  */
 10572                   if (skip == MOVE_LINE_CONTINUED
 10573                       && it->line_wrap == WORD_WRAP)
 10574                     {
 10575                       int prev_x = max (it->current_x - 1, 0);
 10576                       RESTORE_IT (it, &it_backup, backup_data);
 10577                       skip = move_it_in_display_line_to
 10578                         (it, -1, prev_x, MOVE_TO_X);
 10579                     }
 10580 
 10581                   reached = 6;
 10582                 }
 10583             }
 10584 
 10585           if (reached)
 10586             {
 10587               max_current_x = max (it->current_x, max_current_x);
 10588               break;
 10589             }
 10590         }
 10591       else if (BUFFERP (it->object)
 10592                && (it->method == GET_FROM_BUFFER
 10593                    || it->method == GET_FROM_STRETCH)
 10594                && IT_CHARPOS (*it) >= to_charpos
 10595                /* Under bidi iteration, a call to set_iterator_to_next
 10596                   can scan far beyond to_charpos if the initial
 10597                   portion of the next line needs to be reordered.  In
 10598                   that case, give move_it_in_display_line_to another
 10599                   chance below.  */
 10600                && !(it->bidi_p
 10601                     && it->bidi_it.scan_dir == -1))
 10602         skip = MOVE_POS_MATCH_OR_ZV;
 10603       else
 10604         skip = move_it_in_display_line_to (it, to_charpos, -1, MOVE_TO_POS);
 10605 
 10606       switch (skip)
 10607         {
 10608         case MOVE_POS_MATCH_OR_ZV:
 10609           max_current_x = max (it->current_x, max_current_x);
 10610           reached = 8;
 10611           goto out;
 10612 
 10613         case MOVE_NEWLINE_OR_CR:
 10614           max_current_x = max (it->current_x, max_current_x);
 10615           if (!IT_OVERFLOW_NEWLINE_INTO_FRINGE (it))
 10616             it->override_ascent = -1;
 10617           set_iterator_to_next (it, true);
 10618           it->continuation_lines_width = 0;
 10619           break;
 10620 
 10621         case MOVE_LINE_TRUNCATED:
 10622           max_current_x = it->last_visible_x;
 10623           it->continuation_lines_width = 0;
 10624           reseat_at_next_visible_line_start (it, false);
 10625           if ((op & MOVE_TO_POS) != 0
 10626               && (IT_CHARPOS (*it) > to_charpos
 10627                   || (IT_CHARPOS (*it) == to_charpos
 10628                       /* Consider TO_CHARPOS as REACHED if we are at
 10629                          EOB that ends in something other than a newline.  */
 10630                       && to_charpos == ZV
 10631                       && (ZV_BYTE <= 1 || FETCH_BYTE (ZV_BYTE - 1) != '\n')
 10632                       /* But if we have a display or an overlay string
 10633                          at EOB, keep going until we exhaust all the
 10634                          characters of the string(s).  */
 10635                       && (it->sp == 0
 10636                           || (STRINGP (it->string)
 10637                               && (it->current.overlay_string_index < 0
 10638                                   || (it->current.overlay_string_index >= 0
 10639                                       && it->current.overlay_string_index
 10640                                          >= it->n_overlay_strings - 1))
 10641                               && IT_STRING_CHARPOS (*it) >= it->end_charpos)))))
 10642             {
 10643               reached = 9;
 10644               goto out;
 10645             }
 10646           break;
 10647 
 10648         case MOVE_LINE_CONTINUED:
 10649           max_current_x = it->last_visible_x;
 10650           /* For continued lines ending in a tab, some of the glyphs
 10651              associated with the tab are displayed on the current
 10652              line.  Since it->current_x does not include these glyphs,
 10653              we use it->last_visible_x instead.  */
 10654           if (it->c == '\t')
 10655             {
 10656               it->continuation_lines_width += it->last_visible_x;
 10657               /* When moving by vpos, ensure that the iterator really
 10658                  advances to the next line (bug#847, bug#969).  Fixme:
 10659                  do we need to do this in other circumstances?  */
 10660               if (it->current_x != it->last_visible_x
 10661                   && (op & MOVE_TO_VPOS)
 10662                   && !(op & (MOVE_TO_X | MOVE_TO_POS)))
 10663                 {
 10664                   line_start_x = it->current_x + it->pixel_width
 10665                     - it->last_visible_x;
 10666                   if (FRAME_WINDOW_P (it->f))
 10667                     {
 10668                       struct face *face = FACE_FROM_ID (it->f, it->face_id);
 10669                       struct font *face_font = face->font;
 10670 
 10671                       /* When display_line produces a continued line
 10672                          that ends in a TAB, it skips a tab stop that
 10673                          is closer than the font's space character
 10674                          width (see gui_produce_glyphs where it produces
 10675                          the stretch glyph which represents a TAB).
 10676                          We need to reproduce the same logic here.  */
 10677                       eassert (face_font);
 10678                       if (face_font)
 10679                         {
 10680                           if (line_start_x < face_font->space_width)
 10681                             line_start_x
 10682                               += it->tab_width * face_font->space_width;
 10683                         }
 10684                     }
 10685                   set_iterator_to_next (it, false);
 10686                 }
 10687             }
 10688           else
 10689             {
 10690               /* Make sure we do advance, otherwise we might infloop.
 10691                  This could happen when the first display element is
 10692                  wider than the window, or if we have a wrap-prefix
 10693                  that doesn't leave enough space after it to display
 10694                  even a single character.  We only do this for moving
 10695                  through buffer text, as with display/overlay strings
 10696                  we'd need to also compare it->object's, and this is
 10697                  unlikely to happen in that case anyway.  */
 10698               if (IT_CHARPOS (*it) == orig_charpos
 10699                   && it->method == orig_method
 10700                   && orig_method == GET_FROM_BUFFER)
 10701                 set_iterator_to_next (it, false);
 10702               it->continuation_lines_width += it->current_x;
 10703             }
 10704           break;
 10705 
 10706         default:
 10707           emacs_abort ();
 10708         }
 10709 
 10710       /* Reset/increment for the next run.  */
 10711       it->current_x = line_start_x;
 10712       line_start_x = 0;
 10713       it->hpos = 0;
 10714       it->line_number_produced_p = false;
 10715       it->current_y += it->max_ascent + it->max_descent;
 10716       ++it->vpos;
 10717       last_height = it->max_ascent + it->max_descent;
 10718       it->max_ascent = it->max_descent = 0;
 10719     }
 10720 
 10721  out:
 10722 
 10723   /* On text terminals, we may stop at the end of a line in the middle
 10724      of a multi-character glyph.  If the glyph itself is continued,
 10725      i.e. it is actually displayed on the next line, don't treat this
 10726      stopping point as valid; move to the next line instead (unless
 10727      that brings us offscreen).  */
 10728   if (!FRAME_WINDOW_P (it->f)
 10729       && op & MOVE_TO_POS
 10730       && IT_CHARPOS (*it) == to_charpos
 10731       && it->what == IT_CHARACTER
 10732       && it->nglyphs > 1
 10733       && it->line_wrap == WINDOW_WRAP
 10734       && it->current_x == it->last_visible_x - 1
 10735       && it->c != '\n'
 10736       && it->c != '\t'
 10737       && it->w->window_end_valid
 10738       && it->vpos < it->w->window_end_vpos)
 10739     {
 10740       it->continuation_lines_width += it->current_x;
 10741       it->current_x = it->hpos = it->max_ascent = it->max_descent = 0;
 10742       it->current_y += it->max_ascent + it->max_descent;
 10743       ++it->vpos;
 10744       last_height = it->max_ascent + it->max_descent;
 10745     }
 10746 
 10747   if (backup_data)
 10748     bidi_unshelve_cache (backup_data, true);
 10749 
 10750   move_trace ("move_it_to: reached %d\n", reached);
 10751 
 10752   return max_current_x;
 10753 }
 10754 
 10755 
 10756 /* Move iterator IT backward by a specified y-distance DY, DY >= 0.
 10757 
 10758    If DY > 0, move IT backward that many pixels.
 10759    DY = 0 means move IT backward to the preceding line start or to BEGV.
 10760    This function may move over less or more than DY pixels if
 10761    IT->current_y - DY ends up in the middle of a line; in this case
 10762    IT->current_y will be set to the top of the line either before or
 10763    after the exact pixel coordinate.  */
 10764 
 10765 void
 10766 move_it_vertically_backward (struct it *it, int dy)
 10767 {
 10768   int nlines, h;
 10769   struct it it2, it3;
 10770   void *it2data = NULL, *it3data = NULL;
 10771   ptrdiff_t start_pos;
 10772   int nchars_per_row
 10773     = (it->last_visible_x - it->first_visible_x) / FRAME_COLUMN_WIDTH (it->f);
 10774   ptrdiff_t pos_limit;
 10775 
 10776  move_further_back:
 10777   eassert (dy >= 0);
 10778 
 10779   start_pos = IT_CHARPOS (*it);
 10780 
 10781   /* Estimate how many newlines we must move back.  */
 10782   nlines = max (1, dy / default_line_pixel_height (it->w));
 10783   if (it->line_wrap == TRUNCATE || nchars_per_row == 0)
 10784     pos_limit = BEGV;
 10785   else
 10786     pos_limit = max (start_pos - nlines * nchars_per_row, BEGV);
 10787 
 10788   /* Set the iterator's position that many lines back.  But don't go
 10789      back more than NLINES full screen lines -- this wins a day with
 10790      buffers which have very long lines.  */
 10791   while (nlines-- && IT_CHARPOS (*it) > pos_limit)
 10792     back_to_previous_visible_line_start (it);
 10793 
 10794   /* Reseat the iterator here.  When moving backward, we don't want
 10795      reseat to skip forward over invisible text, set up the iterator
 10796      to deliver from overlay strings at the new position etc.  So,
 10797      use reseat_1 here.  */
 10798   reseat_1 (it, it->current.pos, true);
 10799 
 10800   /* We are now surely at a line start.  */
 10801   it->current_x = it->hpos = 0; /* FIXME: this is incorrect when bidi
 10802                                    reordering is in effect.  */
 10803   it->continuation_lines_width = 0;
 10804 
 10805   /* Move forward and see what y-distance we moved.  First move to the
 10806      start of the next line so that we get its height.  We need this
 10807      height to be able to tell whether we reached the specified
 10808      y-distance.  */
 10809   SAVE_IT (it2, *it, it2data);
 10810   it2.max_ascent = it2.max_descent = 0;
 10811   do
 10812     {
 10813       move_it_to (&it2, start_pos, -1, -1, it2.vpos + 1,
 10814                   MOVE_TO_POS | MOVE_TO_VPOS);
 10815     }
 10816   while (!(IT_POS_VALID_AFTER_MOVE_P (&it2)
 10817            /* If we are in a display string which starts at START_POS,
 10818               and that display string includes a newline, and we are
 10819               right after that newline (i.e. at the beginning of a
 10820               display line), exit the loop, because otherwise we will
 10821               infloop, since move_it_to will see that it is already at
 10822               START_POS and will not move.  */
 10823            || (it2.method == GET_FROM_STRING
 10824                && IT_CHARPOS (it2) == start_pos
 10825                && SREF (it2.string, IT_STRING_BYTEPOS (it2) - 1) == '\n')));
 10826   eassert (IT_CHARPOS (*it) >= BEGV);
 10827   SAVE_IT (it3, it2, it3data);
 10828 
 10829   move_it_to (&it2, start_pos, -1, -1, -1, MOVE_TO_POS);
 10830   eassert (IT_CHARPOS (*it) >= BEGV);
 10831   /* H is the actual vertical distance from the position in *IT
 10832      and the starting position.  */
 10833   h = it2.current_y - it->current_y;
 10834   /* NLINES is the distance in number of lines.  */
 10835   nlines = it2.vpos - it->vpos;
 10836 
 10837   /* Correct IT's y and vpos position
 10838      so that they are relative to the starting point.  */
 10839   it->vpos -= nlines;
 10840   it->current_y -= h;
 10841 
 10842   if (dy == 0)
 10843     {
 10844       /* DY == 0 means move to the start of the screen line.  The
 10845          value of nlines is > 0 if continuation lines were involved,
 10846          or if the original IT position was at start of a line.  */
 10847       RESTORE_IT (it, it, it2data);
 10848       if (nlines > 0)
 10849         move_it_by_lines (it, nlines);
 10850       /* The above code moves us to some position NLINES down,
 10851          usually to its first glyph (leftmost in an L2R line), but
 10852          that's not necessarily the start of the line, under bidi
 10853          reordering.  We want to get to the character position
 10854          that is immediately after the newline of the previous
 10855          line.  */
 10856       if (it->bidi_p
 10857           && !it->continuation_lines_width
 10858           && !STRINGP (it->string)
 10859           && IT_CHARPOS (*it) > BEGV
 10860           && FETCH_BYTE (IT_BYTEPOS (*it) - 1) != '\n')
 10861         {
 10862           ptrdiff_t cp = IT_CHARPOS (*it), bp = IT_BYTEPOS (*it);
 10863 
 10864           dec_both (&cp, &bp);
 10865           SET_WITH_NARROWED_BEGV (it, cp,
 10866                                   find_newline_no_quit (cp, bp, -1, NULL),
 10867                                   get_small_narrowing_begv (it->w, IT_CHARPOS (*it)));
 10868           move_it_to (it, cp, -1, -1, -1, MOVE_TO_POS);
 10869         }
 10870       bidi_unshelve_cache (it3data, true);
 10871     }
 10872   else
 10873     {
 10874       /* The y-position we try to reach, relative to *IT.
 10875          Note that H has been subtracted in front of the if-statement.  */
 10876       int target_y = it->current_y + h - dy;
 10877       int y0 = it3.current_y;
 10878       int y1;
 10879       int line_height;
 10880 
 10881       RESTORE_IT (&it3, &it3, it3data);
 10882       y1 = line_bottom_y (&it3);
 10883       line_height = y1 - y0;
 10884       RESTORE_IT (it, it, it2data);
 10885       /* If we did not reach target_y, try to move further backward if
 10886          we can.  If we moved too far backward, try to move forward.  */
 10887       if (target_y < it->current_y
 10888           /* This is heuristic.  In a window that's 3 lines high, with
 10889              a line height of 13 pixels each, recentering with point
 10890              on the bottom line will try to move -39/2 = 19 pixels
 10891              backward.  Try to avoid moving into the first line.  */
 10892           && (it->current_y - target_y
 10893               > min (window_box_height (it->w), line_height * 2 / 3))
 10894           && IT_CHARPOS (*it) > BEGV)
 10895         {
 10896           move_trace ("  not far enough -> move_vert %d\n",
 10897                       target_y - it->current_y);
 10898           dy = it->current_y - target_y;
 10899           goto move_further_back;
 10900         }
 10901       else if (target_y >= it->current_y + line_height
 10902                && IT_CHARPOS (*it) < ZV)
 10903         {
 10904           /* Should move forward by at least one line, maybe more.
 10905 
 10906              Note: Calling move_it_by_lines can be expensive on
 10907              terminal frames, where compute_motion is used (via
 10908              vmotion) to do the job, when there are very long lines
 10909              and truncate-lines is nil.  That's the reason for
 10910              treating terminal frames specially here.  */
 10911 
 10912           if (!FRAME_WINDOW_P (it->f))
 10913             move_it_vertically (it, target_y - it->current_y);
 10914           else
 10915             {
 10916               struct text_pos last_pos;
 10917               int last_y, last_vpos;
 10918               do
 10919                 {
 10920                   last_pos = it->current.pos;
 10921                   last_y = it->current_y;
 10922                   last_vpos = it->vpos;
 10923                   move_it_by_lines (it, 1);
 10924                 }
 10925               while (target_y > it->current_y && IT_CHARPOS (*it) < ZV);
 10926               if (it->current_y > target_y)
 10927                 {
 10928                   reseat (it, last_pos, true);
 10929                   it->current_y = last_y;
 10930                   it->vpos = last_vpos;
 10931                 }
 10932             }
 10933         }
 10934     }
 10935 }
 10936 
 10937 
 10938 /* Move IT by a specified amount of pixel lines DY.  DY negative means
 10939    move backwards.  DY = 0 means move to start of screen line.  At the
 10940    end, IT will be on the start of a screen line.  */
 10941 
 10942 void
 10943 move_it_vertically (struct it *it, int dy)
 10944 {
 10945   if (dy <= 0)
 10946     move_it_vertically_backward (it, -dy);
 10947   else
 10948     {
 10949       move_trace ("move_it_v: from %td, %d\n", IT_CHARPOS (*it), dy);
 10950       move_it_to (it, ZV, -1, it->current_y + dy, -1,
 10951                   MOVE_TO_POS | MOVE_TO_Y);
 10952       move_trace ("move_it_v: to %td\n", IT_CHARPOS (*it));
 10953 
 10954       /* If buffer ends in ZV without a newline, move to the start of
 10955          the line to satisfy the post-condition.  */
 10956       if (IT_CHARPOS (*it) == ZV
 10957           && ZV > BEGV
 10958           && FETCH_BYTE (IT_BYTEPOS (*it) - 1) != '\n')
 10959         move_it_by_lines (it, 0);
 10960     }
 10961 }
 10962 
 10963 
 10964 /* Move iterator IT past the end of the text line it is in.  */
 10965 
 10966 void
 10967 move_it_past_eol (struct it *it)
 10968 {
 10969   enum move_it_result rc;
 10970 
 10971   rc = move_it_in_display_line_to (it, Z, 0, MOVE_TO_POS);
 10972   if (rc == MOVE_NEWLINE_OR_CR)
 10973     set_iterator_to_next (it, false);
 10974 }
 10975 
 10976 
 10977 /* Move IT by a specified number DVPOS of screen lines down.  DVPOS
 10978    negative means move up.  DVPOS == 0 means move to the start of the
 10979    screen line.
 10980 
 10981    Optimization idea: If we would know that IT->f doesn't use
 10982    a face with proportional font, we could be faster for
 10983    truncate-lines nil.  */
 10984 
 10985 void
 10986 move_it_by_lines (struct it *it, ptrdiff_t dvpos)
 10987 {
 10988 
 10989   /* The commented-out optimization uses vmotion on terminals.  This
 10990      gives bad results, because elements like it->what, on which
 10991      callers such as pos_visible_p rely, aren't updated.  */
 10992   /* struct position pos;
 10993     if (!FRAME_WINDOW_P (it->f))
 10994     {
 10995       struct text_pos textpos;
 10996 
 10997       pos = *vmotion (IT_CHARPOS (*it), dvpos, it->w);
 10998       SET_TEXT_POS (textpos, pos.bufpos, pos.bytepos);
 10999       reseat (it, textpos, true);
 11000       it->vpos += pos.vpos;
 11001       it->current_y += pos.vpos;
 11002     }
 11003     else */
 11004 
 11005   if (dvpos == 0)
 11006     {
 11007       /* DVPOS == 0 means move to the start of the screen line.  */
 11008       move_it_vertically_backward (it, 0);
 11009       /* Let next call to line_bottom_y calculate real line height.  */
 11010       last_height = 0;
 11011     }
 11012   else if (dvpos > 0)
 11013     {
 11014       move_it_to (it, -1, -1, -1, it->vpos + dvpos, MOVE_TO_VPOS);
 11015       if (!IT_POS_VALID_AFTER_MOVE_P (it))
 11016         {
 11017           /* Only move to the next buffer position if we ended up in a
 11018              string from display property, not in an overlay string
 11019              (before-string or after-string).  That is because the
 11020              latter don't conceal the underlying buffer position, so
 11021              we can ask to move the iterator to the exact position we
 11022              are interested in.  Note that, even if we are already at
 11023              IT_CHARPOS (*it), the call below is not a no-op, as it
 11024              will detect that we are at the end of the string, pop the
 11025              iterator, and compute it->current_x and it->hpos
 11026              correctly.  */
 11027           move_it_to (it, IT_CHARPOS (*it) + it->string_from_display_prop_p,
 11028                       -1, -1, -1, MOVE_TO_POS);
 11029         }
 11030     }
 11031   else
 11032     {
 11033       struct it it2;
 11034       void *it2data = NULL;
 11035       ptrdiff_t start_charpos, orig_charpos, i;
 11036       int nchars_per_row
 11037         = (it->last_visible_x - it->first_visible_x) / FRAME_COLUMN_WIDTH (it->f);
 11038       bool hit_pos_limit = false;
 11039       ptrdiff_t pos_limit;
 11040 
 11041       /* Start at the beginning of the screen line containing IT's
 11042          position.  This may actually move vertically backwards,
 11043          in case of overlays, so adjust dvpos accordingly.  */
 11044       dvpos += it->vpos;
 11045       orig_charpos = IT_CHARPOS (*it);
 11046       move_it_vertically_backward (it, 0);
 11047       dvpos -= it->vpos;
 11048 
 11049       /* Go back -DVPOS buffer lines, but no farther than -DVPOS full
 11050          screen lines, and reseat the iterator there.  */
 11051       start_charpos = IT_CHARPOS (*it);
 11052       if (it->line_wrap == TRUNCATE || nchars_per_row == 0)
 11053         pos_limit = BEGV;
 11054       else
 11055         pos_limit = max (start_charpos + dvpos * nchars_per_row, BEGV);
 11056 
 11057       for (i = -dvpos; i > 0 && IT_CHARPOS (*it) > pos_limit; --i)
 11058         back_to_previous_visible_line_start (it);
 11059       if (i > 0 && IT_CHARPOS (*it) <= pos_limit)
 11060         hit_pos_limit = true;
 11061       reseat (it, it->current.pos, true);
 11062 
 11063       /* Move further back if we end up in a string or an image.  */
 11064       while (!IT_POS_VALID_AFTER_MOVE_P (it))
 11065         {
 11066           /* First try to move to start of display line.  */
 11067           dvpos += it->vpos;
 11068           move_it_vertically_backward (it, 0);
 11069           dvpos -= it->vpos;
 11070           if (IT_POS_VALID_AFTER_MOVE_P (it))
 11071             break;
 11072           /* If start of line is still in string or image,
 11073              move further back.  */
 11074           back_to_previous_visible_line_start (it);
 11075           reseat (it, it->current.pos, true);
 11076           dvpos--;
 11077         }
 11078 
 11079       it->current_x = it->hpos = 0;
 11080 
 11081       /* Above call may have moved too far if continuation lines
 11082          are involved.  Scan forward and see if it did.  */
 11083       SAVE_IT (it2, *it, it2data);
 11084       it2.vpos = it2.current_y = 0;
 11085       move_it_to (&it2, start_charpos, -1, -1, -1, MOVE_TO_POS);
 11086       it->vpos -= it2.vpos;
 11087       it->current_y -= it2.current_y;
 11088       it->current_x = it->hpos = 0;
 11089 
 11090       /* If we moved too far back, move IT some lines forward.  */
 11091       if (it2.vpos > -dvpos)
 11092         {
 11093           int delta = it2.vpos + dvpos;
 11094 
 11095           RESTORE_IT (&it2, &it2, it2data);
 11096           SAVE_IT (it2, *it, it2data);
 11097           move_it_to (it, -1, -1, -1, it->vpos + delta, MOVE_TO_VPOS);
 11098           /* Move back again if we got too far ahead,
 11099              or didn't move at all.  */
 11100           if (it->vpos - it2.vpos > delta || IT_CHARPOS (*it) == orig_charpos)
 11101             RESTORE_IT (it, &it2, it2data);
 11102           else
 11103             bidi_unshelve_cache (it2data, true);
 11104         }
 11105       else if (hit_pos_limit && pos_limit > BEGV
 11106                && dvpos < 0 && it2.vpos < -dvpos)
 11107         {
 11108           /* If we hit the limit, but still didn't make it far enough
 11109              back, that means there's a display string with a newline
 11110              covering a large chunk of text, and that caused
 11111              back_to_previous_visible_line_start try to go too far.
 11112              Punish those who commit such atrocities by going back
 11113              until we've reached DVPOS, after lifting the limit, which
 11114              could make it slow for very long lines.  "If it hurts,
 11115              don't do that!"  */
 11116           dvpos += it2.vpos;
 11117           RESTORE_IT (it, it, it2data);
 11118           for (i = -dvpos; i > 0; --i)
 11119             {
 11120               back_to_previous_visible_line_start (it);
 11121               it->vpos--;
 11122             }
 11123           reseat_1 (it, it->current.pos, true);
 11124         }
 11125       else
 11126         RESTORE_IT (it, it, it2data);
 11127     }
 11128 }
 11129 
 11130 int
 11131 partial_line_height (struct it *it_origin)
 11132 {
 11133   /* In a buffer with very long and truncated lines, we ignore the
 11134      possibly-partial height of the last line in the window: it is too
 11135      expensive to compute that (since in most cases that involves
 11136      going all the way to ZV), and the effect of ignoring it is
 11137      relatively minor.  */
 11138   if (XBUFFER (it_origin->w->contents)->long_line_optimizations_p
 11139       && it_origin->line_wrap == TRUNCATE)
 11140     return 0;
 11141 
 11142   int partial_height;
 11143   void *it_data = NULL;
 11144   struct it it;
 11145   SAVE_IT (it, *it_origin, it_data);
 11146   move_it_to (&it, ZV, -1, it.last_visible_y, -1,
 11147               MOVE_TO_POS | MOVE_TO_Y);
 11148   if (it.what == IT_EOB)
 11149     {
 11150       int vis_height = it.last_visible_y - it.current_y;
 11151       int height = it.ascent + it.descent;
 11152       partial_height = (vis_height < height) ? vis_height : 0;
 11153     }
 11154   else
 11155     {
 11156       int last_line_y = it.current_y;
 11157       move_it_by_lines (&it, 1);
 11158       partial_height = (it.current_y > it.last_visible_y)
 11159         ? it.last_visible_y - last_line_y : 0;
 11160     }
 11161   RESTORE_IT (&it, &it, it_data);
 11162   return partial_height;
 11163 }
 11164 
 11165 /* Approximate move_it_in_display_line_to for very long and truncated
 11166    display lines, when moving horizontally.  This is used when the
 11167    buffer's long_line_optimizations_p flag is set.  It ignores various
 11168    complications, like different font sizes, invisible text, display
 11169    and overlay strings, and, to some degree, bidirectional text.  So
 11170    caveat emptor!
 11171 
 11172    Starting from IT's position, reseat IT after skipping NCHARS
 11173    characters or to the next newline/ZV, whichever comes first.  Return
 11174    what move_it_in_display_line_to would have returned in this case.  */
 11175 
 11176 static enum move_it_result
 11177 fast_move_it_horizontally (struct it *it, ptrdiff_t nchars)
 11178 {
 11179   ptrdiff_t nl_bytepos;
 11180   ptrdiff_t nl_pos = find_newline_no_quit (IT_CHARPOS (*it), IT_BYTEPOS (*it),
 11181                                            1, &nl_bytepos);
 11182   struct text_pos new_pos;
 11183   enum move_it_result move_result;
 11184 
 11185   if (nl_pos - IT_CHARPOS (*it) > nchars)
 11186     {
 11187       SET_TEXT_POS (new_pos,
 11188                     IT_CHARPOS (*it) + nchars,
 11189                     CHAR_TO_BYTE (IT_CHARPOS (*it) + nchars));
 11190       move_result = MOVE_X_REACHED;
 11191     }
 11192   else
 11193     {
 11194       if (nl_bytepos < ZV_BYTE
 11195           || (nl_bytepos > BEGV_BYTE
 11196               && FETCH_BYTE (nl_bytepos - 1) == '\n'))
 11197         {
 11198           nl_pos--;
 11199           nl_bytepos--;
 11200           move_result = MOVE_NEWLINE_OR_CR;
 11201         }
 11202       else
 11203         move_result = MOVE_POS_MATCH_OR_ZV;
 11204       SET_TEXT_POS (new_pos, nl_pos, nl_bytepos);
 11205     }
 11206   reseat (it, new_pos, false);
 11207   return move_result;
 11208 }
 11209 
 11210 /* Return true if IT points into the middle of a display vector.  */
 11211 
 11212 bool
 11213 in_display_vector_p (struct it *it)
 11214 {
 11215   return (it->method == GET_FROM_DISPLAY_VECTOR
 11216           && it->current.dpvec_index > 0
 11217           && it->dpvec + it->current.dpvec_index != it->dpend);
 11218 }
 11219 
 11220 /* This is like Fwindow_text_pixel_size but assumes that WINDOW's buffer
 11221    is the current buffer.  Fbuffer_text_pixel_size calls it after it has
 11222    set WINDOW's buffer to the buffer specified by its BUFFER_OR_NAME
 11223    argument.  */
 11224 static Lisp_Object
 11225 window_text_pixel_size (Lisp_Object window, Lisp_Object from, Lisp_Object to,
 11226                         Lisp_Object x_limit, Lisp_Object y_limit,
 11227                         Lisp_Object mode_lines, Lisp_Object ignore_line_at_end)
 11228 {
 11229   struct window *w = decode_live_window (window);
 11230   struct it it;
 11231   ptrdiff_t start, end, bpos;
 11232   struct text_pos startp;
 11233   void *itdata = NULL;
 11234   int c, max_x = 0, max_y = 0, x = 0, y = 0, vertical_offset = 0, doff = 0;
 11235 
 11236   if (NILP (from))
 11237     {
 11238       start = BEGV;
 11239       bpos = BEGV_BYTE;
 11240     }
 11241   else if (EQ (from, Qt))
 11242     {
 11243       start = BEGV;
 11244       bpos = BEGV_BYTE;
 11245       while (bpos < ZV_BYTE)
 11246         {
 11247           c = FETCH_BYTE (bpos);
 11248           if (!(c == ' ' || c == '\t' || c == '\n' || c == '\r'))
 11249             break;
 11250           inc_both (&start, &bpos);
 11251         }
 11252       while (bpos > BEGV_BYTE)
 11253         {
 11254           dec_both (&start, &bpos);
 11255           c = FETCH_BYTE (bpos);
 11256           if (!(c == ' ' || c == '\t'))
 11257             break;
 11258         }
 11259     }
 11260   else if (CONSP (from))
 11261     {
 11262       start = clip_to_bounds (BEGV, fix_position (XCAR (from)), ZV);
 11263       bpos = CHAR_TO_BYTE (start);
 11264       CHECK_FIXNUM (XCDR (from));
 11265       vertical_offset = XFIXNUM (XCDR (from));
 11266     }
 11267   else
 11268     {
 11269       start = clip_to_bounds (BEGV, fix_position (from), ZV);
 11270       bpos = CHAR_TO_BYTE (start);
 11271     }
 11272 
 11273   SET_TEXT_POS (startp, start, bpos);
 11274 
 11275   if (NILP (to))
 11276     end = ZV;
 11277   else if (EQ (to, Qt))
 11278     {
 11279       end = ZV;
 11280       bpos = ZV_BYTE;
 11281       while (bpos > BEGV_BYTE)
 11282         {
 11283           dec_both (&end, &bpos);
 11284           c = FETCH_BYTE (bpos);
 11285           if (!(c == ' ' || c == '\t' || c == '\n' || c == '\r'))
 11286             {
 11287               inc_both (&end, &bpos);
 11288               break;
 11289             }
 11290         }
 11291       while (bpos < ZV_BYTE)
 11292         {
 11293           c = fetch_char_advance (&end, &bpos);
 11294           if (!(c == ' ' || c == '\t'))
 11295             break;
 11296         }
 11297     }
 11298   else
 11299     end = clip_to_bounds (start, fix_position (to), ZV);
 11300 
 11301   if (RANGED_FIXNUMP (0, x_limit, INT_MAX))
 11302     max_x = XFIXNUM (x_limit);
 11303   else if (!NILP (x_limit))
 11304     max_x = INT_MAX;
 11305 
 11306   if (NILP (y_limit))
 11307     max_y = INT_MAX;
 11308   else if (RANGED_FIXNUMP (0, y_limit, INT_MAX))
 11309     max_y = XFIXNUM (y_limit);
 11310 
 11311   itdata = bidi_shelve_cache ();
 11312 
 11313   start_display (&it, w, startp);
 11314 
 11315   int start_y = it.current_y;
 11316 
 11317   /* It makes no sense to measure dimensions of region of text that
 11318      crosses the point where bidi reordering changes scan direction.
 11319      By using unidirectional movement here we at least support the use
 11320      case of measuring regions of text that have a uniformly R2L
 11321      directionality, and regions that begin and end in text of the
 11322      same directionality.  */
 11323   it.bidi_p = false;
 11324 
 11325   int start_x;
 11326   if (vertical_offset != 0)
 11327     {
 11328       int last_y;
 11329       it.current_y = 0;
 11330 
 11331       move_it_by_lines (&it, 0);
 11332 
 11333       /* `move_it_vertically_backward' is called by move_it_vertically
 11334          to move by a negative value (upwards), but it is not always
 11335          guaranteed to leave the iterator at or above the position
 11336          given by the offset, which this loop ensures.  */
 11337       if (vertical_offset < 0)
 11338         {
 11339           while (it.current_y > vertical_offset)
 11340             {
 11341               last_y = it.current_y;
 11342               move_it_vertically_backward (&it,
 11343                                            (abs (vertical_offset)
 11344                                             + it.current_y));
 11345 
 11346               if (it.current_y == last_y)
 11347                 break;
 11348             }
 11349         }
 11350       else
 11351         {
 11352           move_it_vertically (&it, vertical_offset);
 11353         }
 11354 
 11355       it.current_y = (WINDOW_TAB_LINE_HEIGHT (w)
 11356                       + WINDOW_HEADER_LINE_HEIGHT (w));
 11357       start = clip_to_bounds (BEGV, IT_CHARPOS (it), ZV);
 11358       start_y = it.current_y;
 11359       start_x = it.current_x;
 11360     }
 11361   else
 11362     {
 11363       /* Start at the beginning of the line containing FROM.  Otherwise
 11364          IT.current_x will be incorrectly set to zero at some arbitrary
 11365          non-zero X coordinate.  */
 11366       reseat_at_previous_visible_line_start (&it);
 11367       it.current_x = it.hpos = 0;
 11368       if (IT_CHARPOS (it) != start)
 11369         {
 11370           void *it1data = NULL;
 11371           struct it it1;
 11372 
 11373           SAVE_IT (it1, it, it1data);
 11374           move_it_to (&it, start, -1, -1, -1, MOVE_TO_POS);
 11375           /* We could have a display property at START, in which case
 11376              asking move_it_to to stop at START will overshoot and
 11377              stop at position after START.  So we try again, stopping
 11378              before START, and account for the width of the last
 11379              buffer position manually.  */
 11380           if (IT_CHARPOS (it) > start && start > BEGV)
 11381             {
 11382               ptrdiff_t it1pos = IT_CHARPOS (it1);
 11383               int it1_x = it1.current_x;
 11384 
 11385               RESTORE_IT (&it, &it1, it1data);
 11386               /* If START - 1 is the beginning of screen line,
 11387                  move_it_to will not move, so we need to use a
 11388                  lower-level move_it_in_display_line subroutine, and
 11389                  tell it to move just 1 pixel, so it stops at the next
 11390                  display element.  */
 11391               if (start - 1 > it1pos)
 11392                 move_it_to (&it, start - 1, -1, -1, -1, MOVE_TO_POS);
 11393               else
 11394                 move_it_in_display_line (&it, start, it1_x + 1,
 11395                                          MOVE_TO_POS | MOVE_TO_X);
 11396               move_it_to (&it, start - 1, -1, -1, -1, MOVE_TO_POS);
 11397               start_x = it.current_x;
 11398               /* If we didn't change our buffer position, the pixel
 11399                  width of what's here was not yet accounted for; do it
 11400                  manually.  */
 11401               if (IT_CHARPOS (it) == start - 1)
 11402                 start_x += it.pixel_width;
 11403             }
 11404           else
 11405             {
 11406               start_x = it.current_x;
 11407               bidi_unshelve_cache (it1data, true);
 11408             }
 11409         }
 11410       else
 11411         start_x = it.current_x;
 11412     }
 11413 
 11414   /* Now move to TO.  */
 11415   int move_op = MOVE_TO_POS | MOVE_TO_Y;
 11416   int to_x = -1;
 11417   it.current_y = start_y;
 11418   /* If FROM is on a newline, pretend that we start at the beginning
 11419      of the next line, because the newline takes no place on display.  */
 11420   if (FETCH_BYTE (start) == '\n')
 11421     it.current_x = 0;
 11422   if (!NILP (x_limit))
 11423     {
 11424       it.last_visible_x = max_x;
 11425       /* Actually, we never want move_it_to stop at to_x.  But to make
 11426          sure that move_it_in_display_line_to always moves far enough,
 11427          we set to_x to INT_MAX and specify MOVE_TO_X.  */
 11428       move_op |= MOVE_TO_X;
 11429       to_x = INT_MAX;
 11430     }
 11431 
 11432   void *it2data = NULL;
 11433   struct it it2;
 11434   SAVE_IT (it2, it, it2data);
 11435 
 11436   x = move_it_to (&it, end, to_x, max_y, -1, move_op);
 11437 
 11438   /* We could have a display property at END, in which case asking
 11439      move_it_to to stop at END will overshoot and stop at position
 11440      after END.  So we try again, stopping before END, and account for
 11441      the width of the last buffer position manually.  */
 11442   if (IT_CHARPOS (it) > end)
 11443     {
 11444       end--;
 11445       RESTORE_IT (&it, &it2, it2data);
 11446       x = move_it_to (&it, end, to_x, max_y, -1, move_op);
 11447       /* Add the width of the thing at TO, but only if we didn't
 11448          overshoot it; if we did, it is already accounted for.  Also,
 11449          account for the height of the thing at TO.  */
 11450       if (IT_CHARPOS (it) == end)
 11451         {
 11452           x += it.pixel_width;
 11453 
 11454           /* DTRT if ignore_line_at_end is t.  */
 11455           if (!NILP (ignore_line_at_end))
 11456             doff = (max (it.max_ascent, it.ascent)
 11457                     + max (it.max_descent, it.descent));
 11458           else
 11459             {
 11460               it.max_ascent = max (it.max_ascent, it.ascent);
 11461               it.max_descent = max (it.max_descent, it.descent);
 11462             }
 11463         }
 11464     }
 11465   else
 11466     bidi_unshelve_cache (it2data, true);
 11467 
 11468   if (!NILP (x_limit))
 11469     {
 11470       /* Don't return more than X-LIMIT.  */
 11471       if (x > max_x)
 11472         x = max_x;
 11473     }
 11474 
 11475   /* If text spans more than one screen line, we don't need to adjust
 11476      the x-span for start_x, since the second and subsequent lines
 11477      will begin at zero X coordinate.  */
 11478   if (it.current_y > start_y)
 11479     start_x = 0;
 11480 
 11481   /* Subtract height of header-line and tab-line which was counted
 11482      automatically by start_display.  */
 11483   if (!NILP (ignore_line_at_end))
 11484     y = (it.current_y + doff
 11485          - WINDOW_TAB_LINE_HEIGHT (w)
 11486          - WINDOW_HEADER_LINE_HEIGHT (w));
 11487   else
 11488     y = (it.current_y + it.max_ascent + it.max_descent + doff
 11489          - WINDOW_TAB_LINE_HEIGHT (w) - WINDOW_HEADER_LINE_HEIGHT (w));
 11490 
 11491   /* Don't return more than Y-LIMIT.  */
 11492   if (y > max_y)
 11493     y = max_y;
 11494 
 11495   if ((EQ (mode_lines, Qtab_line) || EQ (mode_lines, Qt))
 11496       && window_wants_tab_line (w))
 11497     /* Add height of tab-line as requested.  */
 11498     {
 11499       Lisp_Object window_tab_line_format
 11500         = window_parameter (w, Qtab_line_format);
 11501 
 11502       y = y + display_mode_line (w, TAB_LINE_FACE_ID,
 11503                                  NILP (window_tab_line_format)
 11504                                  ? BVAR (current_buffer, tab_line_format)
 11505                                  : window_tab_line_format);
 11506     }
 11507 
 11508   if ((EQ (mode_lines, Qheader_line) || EQ (mode_lines, Qt))
 11509       && window_wants_header_line (w))
 11510     {
 11511       Lisp_Object window_header_line_format
 11512         = window_parameter (w, Qheader_line_format);
 11513 
 11514       y = y + display_mode_line (w, HEADER_LINE_FACE_ID,
 11515                                  NILP (window_header_line_format)
 11516                                  ? BVAR (current_buffer, header_line_format)
 11517                                  : window_header_line_format);
 11518     }
 11519 
 11520   if ((EQ (mode_lines, Qmode_line) || EQ (mode_lines, Qt))
 11521       && window_wants_mode_line (w))
 11522     {
 11523       Lisp_Object window_mode_line_format
 11524         = window_parameter (w, Qmode_line_format);
 11525 
 11526       y = y + display_mode_line (w, CURRENT_MODE_LINE_ACTIVE_FACE_ID (w),
 11527                                  NILP (window_mode_line_format)
 11528                                  ? BVAR (current_buffer, mode_line_format)
 11529                                  : window_mode_line_format);
 11530     }
 11531 
 11532   bidi_unshelve_cache (itdata, false);
 11533 
 11534   return (!vertical_offset
 11535           ? Fcons (make_fixnum (x - start_x), make_fixnum (y))
 11536           : list3i (x - start_x, y, start));
 11537 }
 11538 
 11539 DEFUN ("window-text-pixel-size", Fwindow_text_pixel_size, Swindow_text_pixel_size, 0, 7, 0,
 11540        doc: /* Return the size of the text of WINDOW's buffer in pixels.
 11541 WINDOW must be a live window and defaults to the selected one.  The
 11542 return value is a cons of the maximum pixel-width of any text line and
 11543 the pixel-height of all the text lines in the accessible portion of
 11544 buffer text.
 11545 
 11546 If FROM is a cons cell, the return value includes, in addition to the
 11547 dimensions, also a third element that provides the buffer position
 11548 from which measuring of the text dimensions was actually started.
 11549 
 11550 This function exists to allow Lisp programs to adjust the dimensions
 11551 of WINDOW to the buffer text it needs to display.
 11552 
 11553 The optional argument FROM, if non-nil, specifies the first text
 11554 position to consider, and defaults to the minimum accessible position
 11555 of the buffer.  If FROM is a cons, its car specifies a buffer
 11556 position, and its cdr specifies the vertical offset in pixels from
 11557 that position to the first screen line to be measured.  If FROM is t,
 11558 it stands for the minimum accessible position that starts a non-empty
 11559 line.  TO, if non-nil, specifies the last text position and defaults
 11560 to the maximum accessible position of the buffer.  If TO is t, it
 11561 stands for the maximum accessible position that ends a non-empty line.
 11562 
 11563 The optional argument X-LIMIT, if non-nil, specifies the maximum X
 11564 coordinate beyond which the text should be ignored.  It is therefore
 11565 also the maximum width that the function can return.  X-LIMIT nil or
 11566 omitted means to use the pixel-width of WINDOW's body.  This default
 11567 means text of truncated lines wider than the window will be ignored;
 11568 specify a non-nil value for X-LIMIT if lines are truncated and you need
 11569 to account for the truncated text.
 11570 
 11571 Use nil for X-LIMIT if you want to know how high WINDOW should become in
 11572 order to fit all of its buffer's text with the width of WINDOW
 11573 unaltered.  Use the maximum width WINDOW may assume if you intend to
 11574 change WINDOW's width.  Use t for the maximum possible value.  Since
 11575 calculating the width of long lines can take some time, it's always a
 11576 good idea to make this argument as small as possible; in particular, if
 11577 the buffer contains long lines that shall be truncated anyway.
 11578 
 11579 The optional argument Y-LIMIT, if non-nil, specifies the maximum Y
 11580 coordinate beyond which the text is to be ignored; it is therefore
 11581 also the maximum height that the function can return (excluding the
 11582 height of the mode- or header-line, if any).  Y-LIMIT nil or omitted
 11583 means consider all of the accessible portion of buffer text up to the
 11584 position specified by TO.  Since calculating the text height of a
 11585 large buffer can take some time, it makes sense to specify this
 11586 argument if the size of the buffer is large or unknown.
 11587 
 11588 Optional argument MODE-LINES nil or omitted means do not include the
 11589 height of the mode-, tab- or header-line of WINDOW in the return value.
 11590 If it is the symbol `mode-line', `tab-line' or `header-line', include
 11591 only the height of that line, if present, in the return value.  If t,
 11592 include the height of any of these, if present, in the return value.
 11593 
 11594 IGNORE-LINE-AT-END, if non-nil, means to not add the height of the
 11595 screen line that includes TO to the returned height of the text.  */)
 11596   (Lisp_Object window, Lisp_Object from, Lisp_Object to, Lisp_Object x_limit,
 11597    Lisp_Object y_limit, Lisp_Object mode_lines, Lisp_Object ignore_line_at_end)
 11598 {
 11599   struct window *w = decode_live_window (window);
 11600   struct buffer *b = XBUFFER (w->contents);
 11601   struct buffer *old_b = NULL;
 11602   Lisp_Object value;
 11603 
 11604   if (b != current_buffer)
 11605     {
 11606       old_b = current_buffer;
 11607       set_buffer_internal_1 (b);
 11608     }
 11609 
 11610   value = window_text_pixel_size (window, from, to, x_limit, y_limit, mode_lines,
 11611                                   ignore_line_at_end);
 11612 
 11613   if (old_b)
 11614     set_buffer_internal_1 (old_b);
 11615 
 11616   return value;
 11617 }
 11618 
 11619 DEFUN ("buffer-text-pixel-size", Fbuffer_text_pixel_size, Sbuffer_text_pixel_size, 0, 4, 0,
 11620        doc: /* Return size of whole text of BUFFER-OR-NAME in WINDOW.
 11621 BUFFER-OR-NAME must specify a live buffer or the name of a live buffer
 11622 and defaults to the current buffer.  WINDOW must be a live window and
 11623 defaults to the selected one.  The return value is a cons of the maximum
 11624 pixel-width of any text line and the pixel-height of all the text lines
 11625 of the buffer specified by BUFFER-OR-NAME.
 11626 
 11627 The optional arguments X-LIMIT and Y-LIMIT have the same meaning as with
 11628 `window-text-pixel-size'.
 11629 
 11630 Do not use this function if the buffer specified by BUFFER-OR-NAME is
 11631 already displayed in WINDOW.  `window-text-pixel-size' is cheaper in
 11632 that case because it does not have to temporarily show that buffer in
 11633 WINDOW.  */)
 11634   (Lisp_Object buffer_or_name, Lisp_Object window, Lisp_Object x_limit,
 11635    Lisp_Object y_limit)
 11636 {
 11637   struct window *w = decode_live_window (window);
 11638   struct buffer *b = (NILP (buffer_or_name)
 11639                       ? current_buffer
 11640                       : XBUFFER (Fget_buffer (buffer_or_name)));
 11641   Lisp_Object buffer, value;
 11642   specpdl_ref count = SPECPDL_INDEX ();
 11643 
 11644   XSETBUFFER (buffer, b);
 11645 
 11646   /* The unwind form of with_echo_area_buffer is what we need here to
 11647      make WINDOW temporarily show our buffer.  */
 11648   /* FIXME: Can we move this into the `if (!EQ (buffer, w->contents))`?  */
 11649   record_unwind_protect (unwind_with_echo_area_buffer,
 11650                          with_echo_area_buffer_unwind_data (w));
 11651 
 11652   set_buffer_internal_1 (b);
 11653 
 11654   if (!EQ (buffer, w->contents))
 11655     {
 11656       wset_buffer (w, buffer);
 11657       set_marker_both (w->pointm, buffer, BEG, BEG_BYTE);
 11658       set_marker_both (w->old_pointm, buffer, BEG, BEG_BYTE);
 11659     }
 11660 
 11661   value = window_text_pixel_size (window, Qnil, Qnil, x_limit, y_limit, Qnil,
 11662                                   Qnil);
 11663 
 11664   unbind_to (count, Qnil);
 11665 
 11666   return value;
 11667 }
 11668 
 11669 
 11670 DEFUN ("display--line-is-continued-p", Fdisplay__line_is_continued_p,
 11671        Sdisplay__line_is_continued_p, 0, 0, 0,
 11672        doc: /* Return non-nil if the current screen line is continued on display.  */)
 11673   (void)
 11674 {
 11675   struct buffer *oldb = current_buffer;
 11676   struct window *w = XWINDOW (selected_window);
 11677   enum move_it_result rc = MOVE_POS_MATCH_OR_ZV;
 11678 
 11679   set_buffer_internal_1 (XBUFFER (w->contents));
 11680 
 11681   if (PT < ZV)
 11682     {
 11683       struct text_pos startpos;
 11684       struct it it;
 11685       void *itdata;
 11686       /* Use a marker, since vertical-motion enters redisplay, which can
 11687          trigger fontifications, which in turn could modify buffer text.  */
 11688       Lisp_Object opoint = Fpoint_marker ();
 11689 
 11690       /* Make sure to start from the beginning of the current screen
 11691          line, so that move_it_in_display_line_to counts pixels correctly.  */
 11692       Fvertical_motion (make_fixnum (0), selected_window, Qnil);
 11693       SET_TEXT_POS (startpos, PT, PT_BYTE);
 11694       itdata = bidi_shelve_cache ();
 11695       start_display (&it, w, startpos);
 11696       /* If lines are truncated, no line is continued.  */
 11697       if (it.line_wrap != TRUNCATE)
 11698         {
 11699           it.glyph_row = NULL;
 11700           rc = move_it_in_display_line_to (&it, ZV, -1, MOVE_TO_POS);
 11701         }
 11702       SET_PT_BOTH (marker_position (opoint), marker_byte_position (opoint));
 11703       bidi_unshelve_cache (itdata, false);
 11704     }
 11705   set_buffer_internal_1 (oldb);
 11706 
 11707   return rc == MOVE_LINE_CONTINUED ? Qt : Qnil;
 11708 }
 11709 
 11710 
 11711 /***********************************************************************
 11712                                Messages
 11713  ***********************************************************************/
 11714 
 11715 /* Return the number of arguments the format string FORMAT needs.  */
 11716 
 11717 static ptrdiff_t
 11718 format_nargs (char const *format)
 11719 {
 11720   ptrdiff_t nargs = 0;
 11721   for (char const *p = format; (p = strchr (p, '%')); p++)
 11722     if (p[1] == '%')
 11723       p++;
 11724     else
 11725       nargs++;
 11726   return nargs;
 11727 }
 11728 
 11729 /* Add a message with format string FORMAT and formatted arguments
 11730    to *Messages*.  */
 11731 
 11732 void
 11733 add_to_log (const char *format, ...)
 11734 {
 11735   va_list ap;
 11736   va_start (ap, format);
 11737   vadd_to_log (format, ap);
 11738   va_end (ap);
 11739 }
 11740 
 11741 void
 11742 vadd_to_log (char const *format, va_list ap)
 11743 {
 11744   ptrdiff_t form_nargs = format_nargs (format);
 11745   ptrdiff_t nargs = 1 + form_nargs;
 11746   Lisp_Object args[10];
 11747   eassert (nargs <= ARRAYELTS (args));
 11748   AUTO_STRING (args0, format);
 11749   args[0] = args0;
 11750   for (ptrdiff_t i = 1; i <= nargs; i++)
 11751     args[i] = va_arg (ap, Lisp_Object);
 11752   Lisp_Object msg = Qnil;
 11753   msg = Fformat_message (nargs, args);
 11754 
 11755   ptrdiff_t len = SBYTES (msg) + 1;
 11756   USE_SAFE_ALLOCA;
 11757   char *buffer = SAFE_ALLOCA (len);
 11758   memcpy (buffer, SDATA (msg), len);
 11759 
 11760   message_dolog (buffer, len - 1, true, STRING_MULTIBYTE (msg));
 11761   SAFE_FREE ();
 11762 }
 11763 
 11764 
 11765 /* Output a newline in the *Messages* buffer if "needs" one.  */
 11766 
 11767 void
 11768 message_log_maybe_newline (void)
 11769 {
 11770   if (message_log_need_newline)
 11771     message_dolog ("", 0, true, false);
 11772 }
 11773 
 11774 
 11775 /* Add a string M of length NBYTES to the message log, optionally
 11776    terminated with a newline when NLFLAG is true.  MULTIBYTE, if
 11777    true, means interpret the contents of M as multibyte.  This
 11778    function calls low-level routines in order to bypass text property
 11779    hooks, etc. which might not be safe to run.
 11780 
 11781    This may GC (insert may run before/after change hooks),
 11782    so the buffer M must NOT point to a Lisp string.  */
 11783 
 11784 void
 11785 message_dolog (const char *m, ptrdiff_t nbytes, bool nlflag, bool multibyte)
 11786 {
 11787   const unsigned char *msg = (const unsigned char *) m;
 11788 
 11789   if (!NILP (Vmemory_full))
 11790     return;
 11791 
 11792   if (!NILP (Vmessage_log_max))
 11793     {
 11794       struct buffer *oldbuf;
 11795       Lisp_Object oldpoint, oldbegv, oldzv;
 11796       int old_windows_or_buffers_changed = windows_or_buffers_changed;
 11797       ptrdiff_t point_at_end = 0;
 11798       ptrdiff_t zv_at_end = 0;
 11799       Lisp_Object old_deactivate_mark;
 11800 
 11801       old_deactivate_mark = Vdeactivate_mark;
 11802       oldbuf = current_buffer;
 11803 
 11804       /* Sanity check, in case the variable has been set to something
 11805          invalid.  */
 11806       if (! STRINGP (Vmessages_buffer_name))
 11807         Vmessages_buffer_name = build_string ("*Messages*");
 11808       /* Ensure the Messages buffer exists, and switch to it.
 11809          If we created it, set the major-mode.  */
 11810       bool newbuffer = NILP (Fget_buffer (Vmessages_buffer_name));
 11811       Fset_buffer (Fget_buffer_create (Vmessages_buffer_name, Qnil));
 11812       if (newbuffer
 11813           && !NILP (Ffboundp (intern ("messages-buffer-mode"))))
 11814         call0 (intern ("messages-buffer-mode"));
 11815 
 11816       bset_undo_list (current_buffer, Qt);
 11817       bset_cache_long_scans (current_buffer, Qnil);
 11818 
 11819       oldpoint = message_dolog_marker1;
 11820       set_marker_restricted_both (oldpoint, Qnil, PT, PT_BYTE);
 11821       oldbegv = message_dolog_marker2;
 11822       set_marker_restricted_both (oldbegv, Qnil, BEGV, BEGV_BYTE);
 11823       oldzv = message_dolog_marker3;
 11824       set_marker_restricted_both (oldzv, Qnil, ZV, ZV_BYTE);
 11825 
 11826       if (PT == Z)
 11827         point_at_end = 1;
 11828       if (ZV == Z)
 11829         zv_at_end = 1;
 11830 
 11831       BEGV = BEG;
 11832       BEGV_BYTE = BEG_BYTE;
 11833       ZV = Z;
 11834       ZV_BYTE = Z_BYTE;
 11835       TEMP_SET_PT_BOTH (Z, Z_BYTE);
 11836 
 11837       /* Insert the string--maybe converting multibyte to single byte
 11838          or vice versa, so that all the text fits the buffer.  */
 11839       if (multibyte
 11840           && NILP (BVAR (current_buffer, enable_multibyte_characters)))
 11841         {
 11842           /* Convert a multibyte string to single-byte
 11843              for the *Message* buffer.  */
 11844           for (ptrdiff_t i = 0; i < nbytes; )
 11845             {
 11846               int char_bytes, c = check_char_and_length (msg + i, &char_bytes);
 11847               char work = CHAR_TO_BYTE8 (c);
 11848               insert_1_both (&work, 1, 1, true, false, false);
 11849               i += char_bytes;
 11850             }
 11851         }
 11852       else if (! multibyte
 11853                && ! NILP (BVAR (current_buffer, enable_multibyte_characters)))
 11854         {
 11855           /* Convert a single-byte string to multibyte
 11856              for the *Message* buffer.  */
 11857           for (ptrdiff_t i = 0; i < nbytes; i++)
 11858             {
 11859               int c = make_char_multibyte (msg[i]);
 11860               unsigned char str[MAX_MULTIBYTE_LENGTH];
 11861               int char_bytes = CHAR_STRING (c, str);
 11862               insert_1_both ((char *) str, 1, char_bytes, true, false, false);
 11863             }
 11864         }
 11865       else if (nbytes)
 11866         insert_1_both (m, chars_in_text (msg, nbytes), nbytes,
 11867                        true, false, false);
 11868 
 11869       if (nlflag)
 11870         {
 11871           ptrdiff_t this_bol, this_bol_byte, prev_bol, prev_bol_byte;
 11872           intmax_t dups;
 11873 
 11874           /* Since we call del_range_both passing false for PREPARE,
 11875              we aren't prepared to run modification hooks (we could
 11876              end up calling modification hooks from another buffer and
 11877              only with AFTER=t, Bug#21824).  */
 11878           specpdl_ref count = SPECPDL_INDEX ();
 11879           specbind (Qinhibit_modification_hooks, Qt);
 11880 
 11881           insert_1_both ("\n", 1, 1, true, false, false);
 11882 
 11883           scan_newline (Z, Z_BYTE, BEG, BEG_BYTE, -2, false);
 11884           this_bol = PT;
 11885           this_bol_byte = PT_BYTE;
 11886 
 11887           /* See if this line duplicates the previous one.
 11888              If so, combine duplicates.  */
 11889           if (this_bol > BEG)
 11890             {
 11891               scan_newline (PT, PT_BYTE, BEG, BEG_BYTE, -2, false);
 11892               prev_bol = PT;
 11893               prev_bol_byte = PT_BYTE;
 11894 
 11895               dups = message_log_check_duplicate (prev_bol_byte,
 11896                                                   this_bol_byte);
 11897               if (dups)
 11898                 {
 11899                   del_range_both (prev_bol, prev_bol_byte,
 11900                                   this_bol, this_bol_byte, false);
 11901                   if (dups > 1)
 11902                     {
 11903                       char dupstr[sizeof " [ times]"
 11904                                   + INT_STRLEN_BOUND (dups)];
 11905 
 11906                       /* If you change this format, don't forget to also
 11907                          change message_log_check_duplicate.  */
 11908                       int duplen = sprintf (dupstr, " [%"PRIdMAX" times]",
 11909                                             dups);
 11910                       TEMP_SET_PT_BOTH (Z - 1, Z_BYTE - 1);
 11911                       insert_1_both (dupstr, duplen, duplen,
 11912                                      true, false, true);
 11913                     }
 11914                 }
 11915             }
 11916 
 11917           /* If we have more than the desired maximum number of lines
 11918              in the *Messages* buffer now, delete the oldest ones.
 11919              This is safe because we don't have undo in this buffer.  */
 11920 
 11921           if (FIXNATP (Vmessage_log_max))
 11922             {
 11923               scan_newline (Z, Z_BYTE, BEG, BEG_BYTE,
 11924                             -XFIXNAT (Vmessage_log_max) - 1, false);
 11925               del_range_both (BEG, BEG_BYTE, PT, PT_BYTE, false);
 11926             }
 11927 
 11928           unbind_to (count, Qnil);
 11929         }
 11930       BEGV = marker_position (oldbegv);
 11931       BEGV_BYTE = marker_byte_position (oldbegv);
 11932 
 11933       if (zv_at_end)
 11934         {
 11935           ZV = Z;
 11936           ZV_BYTE = Z_BYTE;
 11937         }
 11938       else
 11939         {
 11940           ZV = marker_position (oldzv);
 11941           ZV_BYTE = marker_byte_position (oldzv);
 11942         }
 11943 
 11944       if (point_at_end)
 11945         TEMP_SET_PT_BOTH (Z, Z_BYTE);
 11946       else
 11947         /* We can't do Fgoto_char (oldpoint) because it will run some
 11948            Lisp code.  */
 11949         TEMP_SET_PT_BOTH (marker_position (oldpoint),
 11950                           marker_byte_position (oldpoint));
 11951 
 11952       unchain_marker (XMARKER (oldpoint));
 11953       unchain_marker (XMARKER (oldbegv));
 11954       unchain_marker (XMARKER (oldzv));
 11955 
 11956       /* We called insert_1_both above with its 5th argument (PREPARE)
 11957          false, which prevents insert_1_both from calling
 11958          prepare_to_modify_buffer, which in turns prevents us from
 11959          incrementing windows_or_buffers_changed even if *Messages* is
 11960          shown in some window.  So we must manually set
 11961          windows_or_buffers_changed here to make up for that.  */
 11962       windows_or_buffers_changed = old_windows_or_buffers_changed;
 11963       bset_redisplay (current_buffer);
 11964 
 11965       set_buffer_internal (oldbuf);
 11966 
 11967       message_log_need_newline = !nlflag;
 11968       Vdeactivate_mark = old_deactivate_mark;
 11969     }
 11970 }
 11971 
 11972 
 11973 /* We are at the end of the buffer after just having inserted a newline.
 11974    (Note: We depend on the fact we won't be crossing the gap.)
 11975    Check to see if the most recent message looks a lot like the previous one.
 11976    Return 0 if different, 1 if the new one should just replace it, or a
 11977    value N > 1 if we should also append " [N times]".  */
 11978 
 11979 static intmax_t
 11980 message_log_check_duplicate (ptrdiff_t prev_bol_byte, ptrdiff_t this_bol_byte)
 11981 {
 11982   ptrdiff_t i;
 11983   ptrdiff_t len = Z_BYTE - 1 - this_bol_byte;
 11984   bool seen_dots = false;
 11985   unsigned char *p1 = BUF_BYTE_ADDRESS (current_buffer, prev_bol_byte);
 11986   unsigned char *p2 = BUF_BYTE_ADDRESS (current_buffer, this_bol_byte);
 11987 
 11988   for (i = 0; i < len; i++)
 11989     {
 11990       if (i >= 3 && p1[i - 3] == '.' && p1[i - 2] == '.' && p1[i - 1] == '.')
 11991         seen_dots = true;
 11992       if (p1[i] != p2[i])
 11993         return seen_dots;
 11994     }
 11995   p1 += len;
 11996   if (*p1 == '\n')
 11997     return 2;
 11998   if (*p1++ == ' ' && *p1++ == '[')
 11999     {
 12000       char *pend;
 12001       intmax_t n = strtoimax ((char *) p1, &pend, 10);
 12002       if (0 < n && n < INTMAX_MAX && strncmp (pend, " times]\n", 8) == 0)
 12003         return n + 1;
 12004     }
 12005   return 0;
 12006 }
 12007 
 12008 
 12009 /* Display an echo area message M with a specified length of NBYTES
 12010    bytes.  The string may include null characters.  If M is not a
 12011    string, clear out any existing message, and let the mini-buffer
 12012    text show through.
 12013 
 12014    This function cancels echoing.  */
 12015 
 12016 void
 12017 message3 (Lisp_Object m)
 12018 {
 12019   clear_message (true, true);
 12020   cancel_echoing ();
 12021 
 12022   /* First flush out any partial line written with print.  */
 12023   message_log_maybe_newline ();
 12024   if (STRINGP (m))
 12025     {
 12026       ptrdiff_t nbytes = SBYTES (m);
 12027       bool multibyte = STRING_MULTIBYTE (m);
 12028       char *buffer;
 12029       USE_SAFE_ALLOCA;
 12030       SAFE_ALLOCA_STRING (buffer, m);
 12031       message_dolog (buffer, nbytes, true, multibyte);
 12032       SAFE_FREE ();
 12033     }
 12034   if (! inhibit_message)
 12035     message3_nolog (m);
 12036 }
 12037 
 12038 /* Log the message M to stderr.  Log an empty line if M is not a string.  */
 12039 
 12040 static void
 12041 message_to_stderr (Lisp_Object m)
 12042 {
 12043   if (noninteractive_need_newline)
 12044     {
 12045       noninteractive_need_newline = false;
 12046       errputc ('\n');
 12047     }
 12048   if (STRINGP (m))
 12049     {
 12050       Lisp_Object coding_system = Vlocale_coding_system;
 12051       Lisp_Object s;
 12052 
 12053       if (!NILP (Vcoding_system_for_write))
 12054         coding_system = Vcoding_system_for_write;
 12055       if (!NILP (coding_system))
 12056         s = code_convert_string_norecord (m, coding_system, true);
 12057       else
 12058         s = m;
 12059 
 12060       errwrite (SDATA (s), SBYTES (s));
 12061     }
 12062   if (STRINGP (m) || !cursor_in_echo_area)
 12063     errputc ('\n');
 12064 }
 12065 
 12066 /* The non-logging version of message3.
 12067    This does not cancel echoing, because it is used for echoing.
 12068    Perhaps we need to make a separate function for echoing
 12069    and make this cancel echoing.  */
 12070 
 12071 void
 12072 message3_nolog (Lisp_Object m)
 12073 {
 12074   struct frame *sf = SELECTED_FRAME ();
 12075 
 12076   if (FRAME_INITIAL_P (sf))
 12077     message_to_stderr (m);
 12078   /* Error messages get reported properly by cmd_error, so this must be just an
 12079      informative message; if the frame hasn't really been initialized yet, just
 12080      toss it.  */
 12081   else if (INTERACTIVE && sf->glyphs_initialized_p)
 12082     {
 12083       /* Get the frame containing the mini-buffer
 12084          that the selected frame is using.  */
 12085       Lisp_Object mini_window = FRAME_MINIBUF_WINDOW (sf);
 12086       Lisp_Object frame = XWINDOW (mini_window)->frame;
 12087       struct frame *f = XFRAME (frame);
 12088 
 12089       if (FRAME_VISIBLE_P (sf) && !FRAME_VISIBLE_P (f))
 12090         Fmake_frame_visible (frame);
 12091 
 12092       if (STRINGP (m) && SCHARS (m) > 0)
 12093         {
 12094           set_message (m);
 12095           if (minibuffer_auto_raise)
 12096             Fraise_frame (frame);
 12097           /* Assume we are not echoing.
 12098              (If we are, echo_now will override this.)  */
 12099           echo_message_buffer = Qnil;
 12100         }
 12101       else
 12102         clear_message (true, true);
 12103 
 12104       do_pending_window_change (false);
 12105       echo_area_display (true);
 12106       do_pending_window_change (false);
 12107       if (FRAME_TERMINAL (f)->frame_up_to_date_hook)
 12108         (*FRAME_TERMINAL (f)->frame_up_to_date_hook) (f);
 12109     }
 12110 }
 12111 
 12112 
 12113 /* Display a null-terminated echo area message M.  If M is 0, clear
 12114    out any existing message, and let the mini-buffer text show through.
 12115 
 12116    The buffer M must continue to exist until after the echo area gets
 12117    cleared or some other message gets displayed there.  Do not pass
 12118    text that is stored in a Lisp string.  Do not pass text in a buffer
 12119    that was alloca'd.  */
 12120 
 12121 void
 12122 message1 (const char *m)
 12123 {
 12124   message3 (m ? build_unibyte_string (m) : Qnil);
 12125 }
 12126 
 12127 
 12128 /* The non-logging counterpart of message1.  */
 12129 
 12130 void
 12131 message1_nolog (const char *m)
 12132 {
 12133   message3_nolog (m ? build_unibyte_string (m) : Qnil);
 12134 }
 12135 
 12136 /* Display a message M which contains a single %s
 12137    which gets replaced with STRING.  */
 12138 
 12139 void
 12140 message_with_string (const char *m, Lisp_Object string, bool log)
 12141 {
 12142   CHECK_STRING (string);
 12143 
 12144   bool need_message;
 12145   if (noninteractive)
 12146     need_message = !!m;
 12147   else if (!INTERACTIVE)
 12148     need_message = false;
 12149   else
 12150     {
 12151       /* The frame whose minibuffer we're going to display the message on.
 12152          It may be larger than the selected frame, so we need
 12153          to use its buffer, not the selected frame's buffer.  */
 12154       Lisp_Object mini_window;
 12155       struct frame *f, *sf = SELECTED_FRAME ();
 12156 
 12157       /* Get the frame containing the minibuffer
 12158          that the selected frame is using.  */
 12159       mini_window = FRAME_MINIBUF_WINDOW (sf);
 12160       f = XFRAME (WINDOW_FRAME (XWINDOW (mini_window)));
 12161 
 12162       /* Error messages get reported properly by cmd_error, so this must be
 12163          just an informative message; if the frame hasn't really been
 12164          initialized yet, just toss it.  */
 12165       need_message = f->glyphs_initialized_p;
 12166     }
 12167 
 12168   if (need_message)
 12169     {
 12170       AUTO_STRING (fmt, m);
 12171       Lisp_Object msg = CALLN (Fformat_message, fmt, string);
 12172 
 12173       if (noninteractive)
 12174         message_to_stderr (msg);
 12175       else
 12176         {
 12177           if (log)
 12178             message3 (msg);
 12179           else
 12180             message3_nolog (msg);
 12181 
 12182           /* Print should start at the beginning of the message
 12183              buffer next time.  */
 12184           message_buf_print = false;
 12185         }
 12186     }
 12187 }
 12188 
 12189 
 12190 /* Dump an informative message to the minibuf.  If M is 0, clear out
 12191    any existing message, and let the mini-buffer text show through.
 12192 
 12193    The message must be safe ASCII (because when Emacs is
 12194    non-interactive the message is sent straight to stderr without
 12195    encoding first) and the format must not contain ` or ' (because
 12196    this function does not account for `text-quoting-style').  If your
 12197    message and format do not fit into this category, convert your
 12198    arguments to Lisp objects and use Fmessage instead.  */
 12199 
 12200 static void ATTRIBUTE_FORMAT_PRINTF (1, 0)
 12201 vmessage (const char *m, va_list ap)
 12202 {
 12203   if (noninteractive)
 12204     {
 12205       if (m)
 12206         {
 12207           if (noninteractive_need_newline)
 12208             putc ('\n', stderr);
 12209           noninteractive_need_newline = false;
 12210           vfprintf (stderr, m, ap);
 12211           if (!cursor_in_echo_area)
 12212             putc ('\n', stderr);
 12213           fflush (stderr);
 12214         }
 12215     }
 12216   else if (INTERACTIVE)
 12217     {
 12218       /* The frame whose mini-buffer we're going to display the message
 12219          on.  It may be larger than the selected frame, so we need to
 12220          use its buffer, not the selected frame's buffer.  */
 12221       Lisp_Object mini_window;
 12222       struct frame *f, *sf = SELECTED_FRAME ();
 12223 
 12224       /* Get the frame containing the mini-buffer
 12225          that the selected frame is using.  */
 12226       mini_window = FRAME_MINIBUF_WINDOW (sf);
 12227       f = XFRAME (WINDOW_FRAME (XWINDOW (mini_window)));
 12228 
 12229       /* Error messages get reported properly by cmd_error, so this must be
 12230          just an informative message; if the frame hasn't really been
 12231          initialized yet, just toss it.  */
 12232       if (f->glyphs_initialized_p)
 12233         {
 12234           if (m)
 12235             {
 12236               ptrdiff_t len;
 12237               ptrdiff_t maxsize = FRAME_MESSAGE_BUF_SIZE (f);
 12238               USE_SAFE_ALLOCA;
 12239               char *message_buf = SAFE_ALLOCA (maxsize + 1);
 12240 
 12241               len = doprnt (message_buf, maxsize, m, 0, ap);
 12242 
 12243               message3 (make_string (message_buf, len));
 12244               SAFE_FREE ();
 12245             }
 12246           else
 12247             message1 (0);
 12248 
 12249           /* Print should start at the beginning of the message
 12250              buffer next time.  */
 12251           message_buf_print = false;
 12252         }
 12253     }
 12254 }
 12255 
 12256 /* See vmessage for restrictions on the text of the message.  */
 12257 void
 12258 message (const char *m, ...)
 12259 {
 12260   va_list ap;
 12261   va_start (ap, m);
 12262   vmessage (m, ap);
 12263   va_end (ap);
 12264 }
 12265 
 12266 
 12267 /* Display the current message in the current mini-buffer.  This is
 12268    only called from error handlers in process.c, and is not time
 12269    critical.  */
 12270 
 12271 void
 12272 update_echo_area (void)
 12273 {
 12274   if (!NILP (echo_area_buffer[0]))
 12275     {
 12276       Lisp_Object string;
 12277       string = Fcurrent_message ();
 12278       message3 (string);
 12279     }
 12280 }
 12281 
 12282 
 12283 /* Make sure echo area buffers in `echo_buffers' are live.
 12284    If they aren't, make new ones.  */
 12285 
 12286 static void
 12287 ensure_echo_area_buffers (void)
 12288 {
 12289   for (int i = 0; i < 2; i++)
 12290     if (!BUFFERP (echo_buffer[i])
 12291         || !BUFFER_LIVE_P (XBUFFER (echo_buffer[i])))
 12292       {
 12293         Lisp_Object old_buffer = echo_buffer[i];
 12294         static char const name_fmt[] = " *Echo Area %d*";
 12295         char name[sizeof name_fmt + INT_STRLEN_BOUND (int)];
 12296         AUTO_STRING_WITH_LEN (lname, name, sprintf (name, name_fmt, i));
 12297         echo_buffer[i] = Fget_buffer_create (lname, Qnil);
 12298         bset_truncate_lines (XBUFFER (echo_buffer[i]), Qnil);
 12299         /* to force word wrap in echo area -
 12300            it was decided to postpone this*/
 12301         /* XBUFFER (echo_buffer[i])->word_wrap = Qt; */
 12302 
 12303         for (int j = 0; j < 2; j++)
 12304           if (EQ (old_buffer, echo_area_buffer[j]))
 12305             echo_area_buffer[j] = echo_buffer[i];
 12306       }
 12307 }
 12308 
 12309 
 12310 /* Call FN with args A1..A2 with either the current or last displayed
 12311    echo_area_buffer as current buffer.
 12312 
 12313    WHICH zero means use the current message buffer
 12314    echo_area_buffer[0].  If that is nil, choose a suitable buffer
 12315    from echo_buffer[] and clear it.
 12316 
 12317    WHICH > 0 means use echo_area_buffer[1].  If that is nil, choose a
 12318    suitable buffer from echo_buffer[] and clear it.
 12319 
 12320    If WHICH < 0, set echo_area_buffer[1] to echo_area_buffer[0], so
 12321    that the current message becomes the last displayed one, choose a
 12322    suitable buffer for echo_area_buffer[0], and clear it.
 12323 
 12324    Value is what FN returns.  */
 12325 
 12326 static bool
 12327 with_echo_area_buffer (struct window *w, int which,
 12328                        bool (*fn) (void *, Lisp_Object),
 12329                        void *a1, Lisp_Object a2)
 12330 {
 12331   Lisp_Object buffer;
 12332   bool this_one, the_other, clear_buffer_p, rc;
 12333   specpdl_ref count = SPECPDL_INDEX ();
 12334 
 12335   /* If buffers aren't live, make new ones.  */
 12336   ensure_echo_area_buffers ();
 12337 
 12338   clear_buffer_p = false;
 12339 
 12340   if (which == 0)
 12341     this_one = false, the_other = true;
 12342   else if (which > 0)
 12343     this_one = true, the_other = false;
 12344   else
 12345     {
 12346       this_one = false, the_other = true;
 12347       clear_buffer_p = true;
 12348 
 12349       /* We need a fresh one in case the current echo buffer equals
 12350          the one containing the last displayed echo area message.  */
 12351       if (!NILP (echo_area_buffer[this_one])
 12352           && EQ (echo_area_buffer[this_one], echo_area_buffer[the_other]))
 12353         echo_area_buffer[this_one] = Qnil;
 12354     }
 12355 
 12356   /* Choose a suitable buffer from echo_buffer[] if we don't
 12357      have one.  */
 12358   if (NILP (echo_area_buffer[this_one]))
 12359     {
 12360       echo_area_buffer[this_one]
 12361         = (EQ (echo_area_buffer[the_other], echo_buffer[this_one])
 12362            ? echo_buffer[the_other]
 12363            : echo_buffer[this_one]);
 12364       clear_buffer_p = true;
 12365     }
 12366 
 12367   buffer = echo_area_buffer[this_one];
 12368 
 12369   /* Don't get confused by reusing the buffer used for echoing
 12370      for a different purpose.  */
 12371   if (echo_kboard == NULL && EQ (buffer, echo_message_buffer))
 12372     cancel_echoing ();
 12373 
 12374   record_unwind_protect (unwind_with_echo_area_buffer,
 12375                          with_echo_area_buffer_unwind_data (w));
 12376 
 12377   /* Make the echo area buffer current.  Note that for display
 12378      purposes, it is not necessary that the displayed window's buffer
 12379      == current_buffer, except for text property lookup.  So, let's
 12380      only set that buffer temporarily here without doing a full
 12381      Fset_window_buffer.  We must also change w->pointm, though,
 12382      because otherwise an assertions in unshow_buffer fails, and Emacs
 12383      aborts.  */
 12384   set_buffer_internal_1 (XBUFFER (buffer));
 12385   if (w)
 12386     {
 12387       wset_buffer (w, buffer);
 12388       set_marker_both (w->pointm, buffer, BEG, BEG_BYTE);
 12389       set_marker_both (w->old_pointm, buffer, BEG, BEG_BYTE);
 12390     }
 12391 
 12392   bset_undo_list (current_buffer, Qt);
 12393   bset_read_only (current_buffer, Qnil);
 12394   specbind (Qinhibit_read_only, Qt);
 12395   specbind (Qinhibit_modification_hooks, Qt);
 12396 
 12397   if (clear_buffer_p && Z > BEG)
 12398     del_range (BEG, Z);
 12399 
 12400   eassert (BEGV >= BEG);
 12401   eassert (ZV <= Z && ZV >= BEGV);
 12402 
 12403   rc = fn (a1, a2);
 12404 
 12405   eassert (BEGV >= BEG);
 12406   eassert (ZV <= Z && ZV >= BEGV);
 12407 
 12408   unbind_to (count, Qnil);
 12409   return rc;
 12410 }
 12411 
 12412 
 12413 /* Save state that should be preserved around the call to the function
 12414    FN called in with_echo_area_buffer.  */
 12415 
 12416 static Lisp_Object
 12417 with_echo_area_buffer_unwind_data (struct window *w)
 12418 {
 12419   int i = 0;
 12420   Lisp_Object vector, tmp;
 12421 
 12422   /* Reduce consing by keeping one vector in
 12423      Vwith_echo_area_save_vector.  */
 12424   vector = Vwith_echo_area_save_vector;
 12425   Vwith_echo_area_save_vector = Qnil;
 12426 
 12427   if (NILP (vector))
 12428     vector = make_nil_vector (11);
 12429 
 12430   XSETBUFFER (tmp, current_buffer); ASET (vector, i, tmp); ++i;
 12431   ASET (vector, i, Vdeactivate_mark); ++i;
 12432   ASET (vector, i, make_fixnum (windows_or_buffers_changed)); ++i;
 12433 
 12434   if (w)
 12435     {
 12436       XSETWINDOW (tmp, w); ASET (vector, i, tmp); ++i;
 12437       ASET (vector, i, w->contents); ++i;
 12438       ASET (vector, i, make_fixnum (marker_position (w->pointm))); ++i;
 12439       ASET (vector, i, make_fixnum (marker_byte_position (w->pointm))); ++i;
 12440       ASET (vector, i, make_fixnum (marker_position (w->old_pointm))); ++i;
 12441       ASET (vector, i, make_fixnum (marker_byte_position (w->old_pointm))); ++i;
 12442       ASET (vector, i, make_fixnum (marker_position (w->start))); ++i;
 12443       ASET (vector, i, make_fixnum (marker_byte_position (w->start))); ++i;
 12444     }
 12445   else
 12446     {
 12447       int end = i + 8;
 12448       for (; i < end; ++i)
 12449         ASET (vector, i, Qnil);
 12450     }
 12451 
 12452   eassert (i == ASIZE (vector));
 12453   return vector;
 12454 }
 12455 
 12456 
 12457 /* Restore global state from VECTOR which was created by
 12458    with_echo_area_buffer_unwind_data.  */
 12459 
 12460 static void
 12461 unwind_with_echo_area_buffer (Lisp_Object vector)
 12462 {
 12463   set_buffer_internal_1 (XBUFFER (AREF (vector, 0)));
 12464   Vdeactivate_mark = AREF (vector, 1);
 12465   windows_or_buffers_changed = XFIXNAT (AREF (vector, 2));
 12466 
 12467   if (WINDOWP (AREF (vector, 3)))
 12468     {
 12469       struct window *w;
 12470       Lisp_Object buffer;
 12471 
 12472       w = XWINDOW (AREF (vector, 3));
 12473       buffer = AREF (vector, 4);
 12474 
 12475       wset_buffer (w, buffer);
 12476       set_marker_restricted_both (w->pointm, buffer,
 12477                                   XFIXNAT (AREF (vector, 5)),
 12478                                   XFIXNAT (AREF (vector, 6)));
 12479       set_marker_restricted_both (w->old_pointm, buffer,
 12480                                   XFIXNAT (AREF (vector, 7)),
 12481                                   XFIXNAT (AREF (vector, 8)));
 12482       set_marker_restricted_both (w->start, buffer,
 12483                                   XFIXNAT (AREF (vector, 9)),
 12484                                   XFIXNAT (AREF (vector, 10)));
 12485     }
 12486 
 12487   Vwith_echo_area_save_vector = vector;
 12488 }
 12489 
 12490 
 12491 /* Set up the echo area for use by print functions.  MULTIBYTE_P
 12492    means we will print multibyte.  */
 12493 
 12494 void
 12495 setup_echo_area_for_printing (bool multibyte_p)
 12496 {
 12497   /* If we can't find an echo area any more, exit.  */
 12498   if (! FRAME_LIVE_P (XFRAME (selected_frame)))
 12499     Fkill_emacs (Qnil, Qnil);
 12500 
 12501   ensure_echo_area_buffers ();
 12502 
 12503   if (!message_buf_print)
 12504     {
 12505       /* A message has been output since the last time we printed.
 12506          Choose a fresh echo area buffer.  */
 12507       if (EQ (echo_area_buffer[1], echo_buffer[0]))
 12508         echo_area_buffer[0] = echo_buffer[1];
 12509       else
 12510         echo_area_buffer[0] = echo_buffer[0];
 12511 
 12512       /* Switch to that buffer and clear it.  */
 12513       set_buffer_internal (XBUFFER (echo_area_buffer[0]));
 12514       bset_truncate_lines (current_buffer, Qnil);
 12515 
 12516       if (Z > BEG)
 12517         {
 12518           specpdl_ref count = SPECPDL_INDEX ();
 12519           specbind (Qinhibit_read_only, Qt);
 12520           /* Note that undo recording is always disabled.  */
 12521           del_range (BEG, Z);
 12522           unbind_to (count, Qnil);
 12523         }
 12524       TEMP_SET_PT_BOTH (BEG, BEG_BYTE);
 12525 
 12526       /* Set up the buffer for the multibyteness we need.  We always
 12527          set it to be multibyte, except when
 12528          unibyte-display-via-language-environment is non-nil and the
 12529          buffer from which we are called is unibyte, because in that
 12530          case unibyte characters should not be displayed as octal
 12531          escapes.  */
 12532       if (unibyte_display_via_language_environment
 12533           && !multibyte_p
 12534           && !NILP (BVAR (current_buffer, enable_multibyte_characters)))
 12535         Fset_buffer_multibyte (Qnil);
 12536       else if (NILP (BVAR (current_buffer, enable_multibyte_characters)))
 12537         Fset_buffer_multibyte (Qt);
 12538 
 12539       /* Raise the frame containing the echo area.  */
 12540       if (minibuffer_auto_raise)
 12541         {
 12542           struct frame *sf = SELECTED_FRAME ();
 12543           Lisp_Object mini_window;
 12544           mini_window = FRAME_MINIBUF_WINDOW (sf);
 12545           Fraise_frame  (WINDOW_FRAME (XWINDOW (mini_window)));
 12546         }
 12547 
 12548       message_log_maybe_newline ();
 12549       message_buf_print = true;
 12550     }
 12551   else
 12552     {
 12553       if (NILP (echo_area_buffer[0]))
 12554         {
 12555           if (EQ (echo_area_buffer[1], echo_buffer[0]))
 12556             echo_area_buffer[0] = echo_buffer[1];
 12557           else
 12558             echo_area_buffer[0] = echo_buffer[0];
 12559         }
 12560 
 12561       if (current_buffer != XBUFFER (echo_area_buffer[0]))
 12562         {
 12563           /* Someone switched buffers between print requests.  */
 12564           set_buffer_internal (XBUFFER (echo_area_buffer[0]));
 12565           bset_truncate_lines (current_buffer, Qnil);
 12566         }
 12567     }
 12568 }
 12569 
 12570 
 12571 /* Display an echo area message in window W.  Value is true if W's
 12572    height is changed.  If display_last_displayed_message_p,
 12573    display the message that was last displayed, otherwise
 12574    display the current message.  */
 12575 
 12576 static bool
 12577 display_echo_area (struct window *w)
 12578 {
 12579   bool no_message_p, window_height_changed_p;
 12580 
 12581   /* Temporarily disable garbage collections while displaying the echo
 12582      area.  This is done because a GC can print a message itself.
 12583      That message would modify the echo area buffer's contents while a
 12584      redisplay of the buffer is going on, and seriously confuse
 12585      redisplay.  */
 12586   specpdl_ref count = inhibit_garbage_collection ();
 12587 
 12588   /* If there is no message, we must call display_echo_area_1
 12589      nevertheless because it resizes the window.  But we will have to
 12590      reset the echo_area_buffer in question to nil at the end because
 12591      with_echo_area_buffer will set it to an empty buffer.  */
 12592   bool i = display_last_displayed_message_p;
 12593   /* According to the C standard, the integral value
 12594      of a "bool" is always 0 or 1, so this array access is safe here,
 12595      if oddly typed. */
 12596   no_message_p = NILP (echo_area_buffer[i]);
 12597 
 12598   window_height_changed_p
 12599     = with_echo_area_buffer (w, display_last_displayed_message_p,
 12600                              display_echo_area_1, w, Qnil);
 12601 
 12602   if (no_message_p)
 12603     echo_area_buffer[i] = Qnil;
 12604 
 12605   unbind_to (count, Qnil);
 12606   return window_height_changed_p;
 12607 }
 12608 
 12609 
 12610 /* Helper for display_echo_area.  Display the current buffer which
 12611    contains the current echo area message in window W, a mini-window,
 12612    a pointer to which is passed in A1.  A2 is currently not used.
 12613    Change the height of W so that all of the message is displayed.
 12614    Value is true if height of W was changed.  */
 12615 
 12616 static bool
 12617 display_echo_area_1 (void *a1, Lisp_Object a2)
 12618 {
 12619   struct window *w = a1;
 12620   Lisp_Object window;
 12621   struct text_pos start;
 12622 
 12623   /* We are about to enter redisplay without going through
 12624      redisplay_internal, so we need to forget these faces by hand
 12625      here.  */
 12626   forget_escape_and_glyphless_faces ();
 12627 
 12628   /* Do this before displaying, so that we have a large enough glyph
 12629      matrix for the display.  If we can't get enough space for the
 12630      whole text, display the last N lines.  That works by setting w->start.  */
 12631   bool window_height_changed_p = resize_mini_window (w, false);
 12632 
 12633   /* Use the starting position chosen by resize_mini_window.  */
 12634   SET_TEXT_POS_FROM_MARKER (start, w->start);
 12635 
 12636   /* Display.  */
 12637   clear_glyph_matrix (w->desired_matrix);
 12638   XSETWINDOW (window, w);
 12639   void *itdata = bidi_shelve_cache ();
 12640   try_window (window, start, 0);
 12641   bidi_unshelve_cache (itdata, false);
 12642 
 12643   return window_height_changed_p;
 12644 }
 12645 
 12646 
 12647 /* Resize the echo area window to exactly the size needed for the
 12648    currently displayed message, if there is one.  If a mini-buffer
 12649    is active, don't shrink it.  */
 12650 
 12651 void
 12652 resize_echo_area_exactly (void)
 12653 {
 12654   if (BUFFERP (echo_area_buffer[0])
 12655       && WINDOWP (echo_area_window))
 12656     {
 12657       struct window *w = XWINDOW (echo_area_window);
 12658       Lisp_Object resize_exactly = (minibuf_level == 0 ? Qt : Qnil);
 12659       bool resized_p = with_echo_area_buffer (w, 0, resize_mini_window_1,
 12660                                               w, resize_exactly);
 12661       if (resized_p)
 12662         {
 12663           windows_or_buffers_changed = 42;
 12664           update_mode_lines = 30;
 12665           redisplay_internal ();
 12666         }
 12667     }
 12668 }
 12669 
 12670 
 12671 /* Callback function for with_echo_area_buffer, when used from
 12672    resize_echo_area_exactly.  A1 contains a pointer to the window to
 12673    resize, EXACTLY non-nil means resize the mini-window exactly to the
 12674    size of the text displayed.  Value is what resize_mini_window
 12675    returns.  */
 12676 
 12677 static bool
 12678 resize_mini_window_1 (void *a1, Lisp_Object exactly)
 12679 {
 12680   return resize_mini_window (a1, !NILP (exactly));
 12681 }
 12682 
 12683 
 12684 /* Resize mini-window W to fit the size of its contents.  EXACT_P
 12685    means size the window exactly to the size needed.  Otherwise, it's
 12686    only enlarged until W's buffer is empty.
 12687 
 12688    Set W->start to the right place to begin display.  If the whole
 12689    contents fit, start at the beginning.  Otherwise, start so as
 12690    to make the end of the contents appear.  This is particularly
 12691    important for y-or-n-p, but seems desirable generally.
 12692 
 12693    Value is true if the window height has been changed.  */
 12694 
 12695 bool
 12696 resize_mini_window (struct window *w, bool exact_p)
 12697 {
 12698   struct frame *f = XFRAME (w->frame);
 12699   int old_height = WINDOW_BOX_TEXT_HEIGHT (w);
 12700 
 12701   eassert (MINI_WINDOW_P (w));
 12702 
 12703   /* Don't resize windows while redisplaying a window; it would
 12704      confuse redisplay functions when the size of the window they are
 12705      displaying changes from under them.  Such a resizing can happen,
 12706      for instance, when which-func prints a long message while
 12707      we are running fontification-functions.  We're running these
 12708      functions with safe_call which binds inhibit-redisplay to t.  */
 12709   if (!NILP (Vinhibit_redisplay))
 12710     return false;
 12711 
 12712   /* By default, start display at the beginning.  */
 12713   if (redisplay_adhoc_scroll_in_resize_mini_windows)
 12714     set_marker_both (w->start, w->contents,
 12715                      BUF_BEGV (XBUFFER (w->contents)),
 12716                      BUF_BEGV_BYTE (XBUFFER (w->contents)));
 12717 
 12718   /* Nil means don't try to resize.  */
 12719   if ((NILP (Vresize_mini_windows)
 12720        && (NILP (resize_mini_frames) || !FRAME_MINIBUF_ONLY_P (f)))
 12721       || (FRAME_X_P (f) && FRAME_OUTPUT_DATA (f) == NULL))
 12722     return false;
 12723 
 12724   if (FRAME_MINIBUF_ONLY_P (f))
 12725     {
 12726       if (!NILP (resize_mini_frames))
 12727         safe_call1 (Qwindow__resize_mini_frame, WINDOW_FRAME (w));
 12728     }
 12729   else
 12730     {
 12731       struct it it;
 12732       int unit = FRAME_LINE_HEIGHT (f);
 12733       int height, max_height;
 12734       struct text_pos start;
 12735       struct buffer *old_current_buffer = NULL;
 12736       int windows_height = FRAME_INNER_HEIGHT (f);
 12737 
 12738       if (current_buffer != XBUFFER (w->contents))
 12739         {
 12740           old_current_buffer = current_buffer;
 12741           set_buffer_internal (XBUFFER (w->contents));
 12742         }
 12743 
 12744       init_iterator (&it, w, BEGV, BEGV_BYTE, NULL, DEFAULT_FACE_ID);
 12745 
 12746       /* Compute the max. number of lines specified by the user.  */
 12747       if (FLOATP (Vmax_mini_window_height))
 12748         max_height = XFLOAT_DATA (Vmax_mini_window_height) * windows_height;
 12749       else if (FIXNUMP (Vmax_mini_window_height))
 12750         max_height = XFIXNUM (Vmax_mini_window_height) * unit;
 12751       else
 12752         max_height = windows_height / 4;
 12753 
 12754       /* Correct that max. height if it's bogus.  */
 12755       max_height = clip_to_bounds (unit, max_height, windows_height);
 12756 
 12757       /* Find out the height of the text in the window.  */
 12758       last_height = 0;
 12759       move_it_to (&it, ZV, -1, -1, -1, MOVE_TO_POS);
 12760       /* If move_it_to moved to the next visible line after EOB,
 12761          account for the height of the last full line.  */
 12762       if (it.max_ascent == 0 && it.max_descent == 0)
 12763         {
 12764           height = it.current_y;
 12765           /* Don't add the last line's height if lines are truncated
 12766              and the text doesn't end in a newline.
 12767              FIXME: if the text ends in a newline from a display
 12768              property or an overlay string, they lose: the mini-window
 12769              might not show the last empty line.  */
 12770           if (!(it.line_wrap == TRUNCATE
 12771                 && it.current_x <= it.first_visible_x
 12772                 && ZV_BYTE > 1
 12773                 && FETCH_BYTE (ZV_BYTE - 1) != '\n'))
 12774             height += last_height;
 12775         }
 12776       else
 12777         height = it.current_y + it.max_ascent + it.max_descent;
 12778       height -= min (it.extra_line_spacing, it.max_extra_line_spacing);
 12779 
 12780       /* Compute a suitable window start.  */
 12781       if (height > max_height)
 12782         {
 12783           height = (max_height / unit) * unit;
 12784           if (redisplay_adhoc_scroll_in_resize_mini_windows)
 12785             {
 12786               init_iterator (&it, w, ZV, ZV_BYTE, NULL, DEFAULT_FACE_ID);
 12787               move_it_vertically_backward (&it, height - unit);
 12788               /* The following move is usually a no-op when the stuff
 12789                  displayed in the mini-window comes entirely from buffer
 12790                  text, but it is needed when some of it comes from overlay
 12791                  strings, especially when there's an after-string at ZV.
 12792                  This happens with some completion packages, like
 12793                  icomplete, ido-vertical, etc.  With those packages, if we
 12794                  don't force w->start to be at the beginning of a screen
 12795                  line, important parts of the stuff in the mini-window,
 12796                  such as user prompt, will be hidden from view.  */
 12797               move_it_by_lines (&it, 0);
 12798               start = it.current.pos;
 12799               /* Prevent redisplay_window from recentering, and thus from
 12800                  overriding the window-start point we computed here.  */
 12801               w->start_at_line_beg = false;
 12802               SET_MARKER_FROM_TEXT_POS (w->start, start);
 12803             }
 12804         }
 12805       else
 12806         {
 12807           SET_TEXT_POS (start, BEGV, BEGV_BYTE);
 12808           SET_MARKER_FROM_TEXT_POS (w->start, start);
 12809         }
 12810 
 12811       if (EQ (Vresize_mini_windows, Qgrow_only))
 12812         {
 12813           /* Let it grow only, until we display an empty message, in which
 12814              case the window shrinks again.  */
 12815           if (height > old_height)
 12816             grow_mini_window (w, height - old_height);
 12817           else if (height < old_height && (exact_p || BEGV == ZV))
 12818             shrink_mini_window (w);
 12819         }
 12820       else if (height != old_height)
 12821         /* Always resize to exact size needed.  */
 12822         grow_mini_window (w, height - old_height);
 12823 
 12824       if (old_current_buffer)
 12825         set_buffer_internal (old_current_buffer);
 12826     }
 12827 
 12828   return WINDOW_BOX_TEXT_HEIGHT (w) != old_height;
 12829 }
 12830 
 12831 
 12832 /* Value is the current message, a string, or nil if there is no
 12833    current message.  */
 12834 
 12835 Lisp_Object
 12836 current_message (void)
 12837 {
 12838   Lisp_Object msg;
 12839 
 12840   if (!BUFFERP (echo_area_buffer[0]))
 12841     msg = Qnil;
 12842   else
 12843     {
 12844       with_echo_area_buffer (0, 0, current_message_1, &msg, Qnil);
 12845       if (NILP (msg))
 12846         echo_area_buffer[0] = Qnil;
 12847     }
 12848 
 12849   return msg;
 12850 }
 12851 
 12852 
 12853 static bool
 12854 current_message_1 (void *a1, Lisp_Object a2)
 12855 {
 12856   Lisp_Object *msg = a1;
 12857 
 12858   if (Z > BEG)
 12859     *msg = make_buffer_string (BEG, Z, true);
 12860   else
 12861     *msg = Qnil;
 12862   return false;
 12863 }
 12864 
 12865 
 12866 /* Push the current message on Vmessage_stack for later restoration
 12867    by restore_message.  Value is true if the current message isn't
 12868    empty.  This is a relatively infrequent operation, so it's not
 12869    worth optimizing.  */
 12870 
 12871 bool
 12872 push_message (void)
 12873 {
 12874   Lisp_Object msg = current_message ();
 12875   Vmessage_stack = Fcons (msg, Vmessage_stack);
 12876   return STRINGP (msg);
 12877 }
 12878 
 12879 
 12880 /* Restore message display from the top of Vmessage_stack.  */
 12881 
 12882 void
 12883 restore_message (void)
 12884 {
 12885   eassert (CONSP (Vmessage_stack));
 12886   message3_nolog (XCAR (Vmessage_stack));
 12887 }
 12888 
 12889 
 12890 /* Handler for unwind-protect calling pop_message.  */
 12891 
 12892 void
 12893 pop_message_unwind (void)
 12894 {
 12895   /* Pop the top-most entry off Vmessage_stack.  */
 12896   eassert (CONSP (Vmessage_stack));
 12897   Vmessage_stack = XCDR (Vmessage_stack);
 12898 }
 12899 
 12900 
 12901 /* Check that Vmessage_stack is nil.  Called from emacs.c when Emacs
 12902    exits.  If the stack is not empty, we have a missing
 12903    pop_message_unwind somewhere.  */
 12904 
 12905 void
 12906 check_message_stack (void)
 12907 {
 12908   if (!NILP (Vmessage_stack))
 12909     emacs_abort ();
 12910 }
 12911 
 12912 void
 12913 clear_message_stack (void)
 12914 {
 12915   Vmessage_stack = Qnil;
 12916 }
 12917 
 12918 /* Truncate to NCHARS what will be displayed in the echo area the next
 12919    time we display it---but don't redisplay it now.  */
 12920 
 12921 void
 12922 truncate_echo_area (ptrdiff_t nchars)
 12923 {
 12924   if (nchars == 0)
 12925     echo_area_buffer[0] = Qnil;
 12926   else if (!noninteractive
 12927            && INTERACTIVE
 12928            && !NILP (echo_area_buffer[0]))
 12929     {
 12930       struct frame *sf = SELECTED_FRAME ();
 12931       /* Error messages get reported properly by cmd_error, so this must be
 12932          just an informative message; if the frame hasn't really been
 12933          initialized yet, just toss it.  */
 12934       if (sf->glyphs_initialized_p)
 12935         with_echo_area_buffer (0, 0, truncate_message_1,
 12936                                (void *) (intptr_t) nchars, Qnil);
 12937     }
 12938 }
 12939 
 12940 
 12941 /* Helper function for truncate_echo_area.  Truncate the current
 12942    message to at most NCHARS characters.  */
 12943 
 12944 static bool
 12945 truncate_message_1 (void *a1, Lisp_Object a2)
 12946 {
 12947   intptr_t nchars = (intptr_t) a1;
 12948   if (BEG + nchars < Z)
 12949     del_range (BEG + nchars, Z);
 12950   if (Z == BEG)
 12951     echo_area_buffer[0] = Qnil;
 12952   return false;
 12953 }
 12954 
 12955 extern intptr_t garbage_collection_inhibited;
 12956 
 12957 /* Set the current message to STRING.  */
 12958 
 12959 static void
 12960 set_message (Lisp_Object string)
 12961 {
 12962   Lisp_Object message = Qnil;
 12963 
 12964   eassert (STRINGP (string));
 12965 
 12966   if (FUNCTIONP (Vset_message_function)
 12967       /* FIXME: (bug#63253) We should really make the regexp engine re-entrant,
 12968          but in the mean time, let's ignore `set-message-function` when
 12969          called from `probably_quit`.  */
 12970       && !garbage_collection_inhibited)
 12971     {
 12972       specpdl_ref count = SPECPDL_INDEX ();
 12973       specbind (Qinhibit_quit, Qt);
 12974       message = safe_call1 (Vset_message_function, string);
 12975       unbind_to (count, Qnil);
 12976 
 12977       if (STRINGP (message))
 12978         {
 12979           string = message;
 12980           message = Qnil;
 12981         }
 12982     }
 12983 
 12984   if (NILP (message))
 12985     {
 12986       message_enable_multibyte = STRING_MULTIBYTE (string);
 12987 
 12988       with_echo_area_buffer (0, -1, set_message_1, 0, string);
 12989       message_buf_print = false;
 12990       help_echo_showing_p = false;
 12991     }
 12992 
 12993   if (STRINGP (Vdebug_on_message)
 12994       && STRINGP (string)
 12995       && fast_string_match (Vdebug_on_message, string) >= 0)
 12996     call_debugger (list2 (Qerror, string));
 12997 }
 12998 
 12999 
 13000 /* Helper function for set_message.  First argument is ignored and second
 13001    argument has the same meaning as for set_message.
 13002    This function is called with the echo area buffer being current.  */
 13003 
 13004 static bool
 13005 set_message_1 (void *a1, Lisp_Object string)
 13006 {
 13007   eassert (STRINGP (string));
 13008 
 13009   /* Change multibyteness of the echo buffer appropriately.  We always
 13010      set it to be multibyte, except when
 13011      unibyte-display-via-language-environment is non-nil and the
 13012      string to display is unibyte, because in that case unibyte
 13013      characters should not be displayed as octal escapes.  */
 13014   if (!message_enable_multibyte
 13015       && unibyte_display_via_language_environment
 13016       && !NILP (BVAR (current_buffer, enable_multibyte_characters)))
 13017     Fset_buffer_multibyte (Qnil);
 13018   else if (NILP (BVAR (current_buffer, enable_multibyte_characters)))
 13019     Fset_buffer_multibyte (Qt);
 13020 
 13021   bset_truncate_lines (current_buffer, message_truncate_lines ? Qt : Qnil);
 13022   if (!NILP (BVAR (current_buffer, bidi_display_reordering)))
 13023     bset_bidi_paragraph_direction (current_buffer, Qleft_to_right);
 13024 
 13025   /* Insert new message at BEG.  */
 13026   TEMP_SET_PT_BOTH (BEG, BEG_BYTE);
 13027 
 13028   /* This function takes care of single/multibyte conversion.
 13029      We just have to ensure that the echo area buffer has the right
 13030      setting of enable_multibyte_characters.  */
 13031   insert_from_string (string, 0, 0, SCHARS (string), SBYTES (string), true);
 13032 
 13033   return false;
 13034 }
 13035 
 13036 
 13037 /* Clear messages.  CURRENT_P means clear the current message.
 13038    LAST_DISPLAYED_P means clear the message last displayed.  */
 13039 
 13040 void
 13041 clear_message (bool current_p, bool last_displayed_p)
 13042 {
 13043   Lisp_Object preserve = Qnil;
 13044 
 13045   if (current_p)
 13046     {
 13047       if (FUNCTIONP (Vclear_message_function)
 13048           /* FIXME: (bug#63253) Same as for `set-message-function` above.  */
 13049           && !garbage_collection_inhibited)
 13050         {
 13051           specpdl_ref count = SPECPDL_INDEX ();
 13052           specbind (Qinhibit_quit, Qt);
 13053           preserve = safe_call (1, Vclear_message_function);
 13054           unbind_to (count, Qnil);
 13055         }
 13056 
 13057       if (!EQ (preserve, Qdont_clear_message))
 13058         {
 13059           echo_area_buffer[0] = Qnil;
 13060           message_cleared_p = true;
 13061         }
 13062     }
 13063 
 13064   if (last_displayed_p)
 13065     echo_area_buffer[1] = Qnil;
 13066 
 13067   message_buf_print = false;
 13068 }
 13069 
 13070 /* Clear garbaged frames.
 13071 
 13072    This function is used where the old redisplay called
 13073    redraw_garbaged_frames which in turn called redraw_frame which in
 13074    turn called clear_frame.  The call to clear_frame was a source of
 13075    flickering.  I believe a clear_frame is not necessary.  It should
 13076    suffice in the new redisplay to invalidate all current matrices,
 13077    and ensure a complete redisplay of all windows.  */
 13078 
 13079 static void
 13080 clear_garbaged_frames (void)
 13081 {
 13082   if (frame_garbaged)
 13083     {
 13084       Lisp_Object tail, frame;
 13085       struct frame *sf = SELECTED_FRAME ();
 13086 
 13087       FOR_EACH_FRAME (tail, frame)
 13088         {
 13089           struct frame *f = XFRAME (frame);
 13090 
 13091           if (FRAME_REDISPLAY_P (f) && FRAME_GARBAGED_P (f))
 13092             {
 13093               if (f->resized_p
 13094                   /* It makes no sense to redraw a non-selected TTY
 13095                      frame, since that will actually clear the
 13096                      selected frame, and might leave the selected
 13097                      frame with corrupted display, if it happens not
 13098                      to be marked garbaged.  */
 13099                   && !(f != sf && (FRAME_TERMCAP_P (f) || FRAME_MSDOS_P (f))))
 13100                 redraw_frame (f);
 13101               else
 13102                 clear_current_matrices (f);
 13103 
 13104 #ifdef HAVE_WINDOW_SYSTEM
 13105               if (FRAME_WINDOW_P (f)
 13106                   && FRAME_RIF (f)->clear_under_internal_border)
 13107                 FRAME_RIF (f)->clear_under_internal_border (f);
 13108 #endif
 13109               fset_redisplay (f);
 13110               f->garbaged = false;
 13111               f->resized_p = false;
 13112             }
 13113         }
 13114 
 13115       frame_garbaged = false;
 13116     }
 13117 }
 13118 
 13119 
 13120 /* Redisplay the echo area of the selected frame.  If UPDATE_FRAME_P, update
 13121    selected_frame.  */
 13122 
 13123 static void
 13124 echo_area_display (bool update_frame_p)
 13125 {
 13126   Lisp_Object mini_window;
 13127   struct window *w;
 13128   struct frame *f;
 13129   bool window_height_changed_p = false;
 13130   struct frame *sf = SELECTED_FRAME ();
 13131 
 13132   mini_window = FRAME_MINIBUF_WINDOW (sf);
 13133   if (NILP (mini_window))
 13134     return;
 13135 
 13136   w = XWINDOW (mini_window);
 13137   f = XFRAME (WINDOW_FRAME (w));
 13138 
 13139   /* Don't display if frame is invisible or not yet initialized.  */
 13140   if (!FRAME_REDISPLAY_P (f) || !f->glyphs_initialized_p)
 13141     return;
 13142 
 13143 #ifdef HAVE_WINDOW_SYSTEM
 13144   /* When Emacs starts, selected_frame may be the initial terminal
 13145      frame.  If we let this through, a message would be displayed on
 13146      the terminal.  */
 13147   if (FRAME_INITIAL_P (XFRAME (selected_frame)))
 13148     return;
 13149 #endif /* HAVE_WINDOW_SYSTEM */
 13150 
 13151   /* Redraw garbaged frames.  */
 13152   clear_garbaged_frames ();
 13153 
 13154   if (!NILP (echo_area_buffer[0]) || minibuf_level == 0)
 13155     {
 13156       echo_area_window = mini_window;
 13157       window_height_changed_p = display_echo_area (w);
 13158       w->must_be_updated_p = true;
 13159 
 13160       /* Update the display, unless called from redisplay_internal.
 13161          Also don't update the screen during redisplay itself.  The
 13162          update will happen at the end of redisplay, and an update
 13163          here could cause confusion.  */
 13164       if (update_frame_p && !redisplaying_p)
 13165         {
 13166           int n = 0;
 13167 
 13168           /* If the display update has been interrupted by pending
 13169              input, update mode lines in the frame.  Due to the
 13170              pending input, it might have been that redisplay hasn't
 13171              been called, so that mode lines above the echo area are
 13172              garbaged.  This looks odd, so we prevent it here.  */
 13173           if (!display_completed)
 13174             {
 13175               n = redisplay_mode_lines (FRAME_ROOT_WINDOW (f), false);
 13176 
 13177 #ifdef HAVE_WINDOW_SYSTEM
 13178               if (FRAME_WINDOW_P (f)
 13179                   && FRAME_RIF (f)->clear_under_internal_border)
 13180                 FRAME_RIF (f)->clear_under_internal_border (f);
 13181 #endif
 13182             }
 13183 
 13184           if (window_height_changed_p
 13185               /* Don't do this if Emacs is shutting down.  Redisplay
 13186                  needs to run hooks.  */
 13187               && !NILP (Vrun_hooks))
 13188             {
 13189               /* Must update other windows.  Likewise as in other
 13190                  cases, don't let this update be interrupted by
 13191                  pending input.  */
 13192               specpdl_ref count = SPECPDL_INDEX ();
 13193               specbind (Qredisplay_dont_pause, Qt);
 13194               fset_redisplay (f);
 13195               redisplay_internal ();
 13196               unbind_to (count, Qnil);
 13197             }
 13198           else if (FRAME_WINDOW_P (f) && n == 0)
 13199             {
 13200               /* Window configuration is the same as before.
 13201                  Can do with a display update of the echo area,
 13202                  unless we displayed some mode lines.  */
 13203               update_single_window (w);
 13204               flush_frame (f);
 13205             }
 13206           else
 13207             update_frame (f, true, true);
 13208 
 13209           /* If cursor is in the echo area, make sure that the next
 13210              redisplay displays the minibuffer, so that the cursor will
 13211              be replaced with what the minibuffer wants.  */
 13212           if (cursor_in_echo_area)
 13213             wset_redisplay (XWINDOW (mini_window));
 13214         }
 13215     }
 13216   else if (!EQ (mini_window, selected_window))
 13217     wset_redisplay (XWINDOW (mini_window));
 13218 
 13219   /* Last displayed message is now the current message.  */
 13220   echo_area_buffer[1] = echo_area_buffer[0];
 13221   /* Inform read_char that we're not echoing.  */
 13222   echo_message_buffer = Qnil;
 13223 
 13224   /* Prevent redisplay optimization in redisplay_internal by resetting
 13225      this_line_start_pos.  This is done because the mini-buffer now
 13226      displays the message instead of its buffer text.  */
 13227   if (EQ (mini_window, selected_window))
 13228     CHARPOS (this_line_start_pos) = 0;
 13229 
 13230   if (window_height_changed_p)
 13231     {
 13232       fset_redisplay (f);
 13233 
 13234       /* If window configuration was changed, frames may have been
 13235          marked garbaged.  Clear them or we will experience
 13236          surprises wrt scrolling.
 13237          FIXME: How/why/when?  */
 13238       clear_garbaged_frames ();
 13239     }
 13240 }
 13241 
 13242 /* True if W's buffer was changed but not saved.  */
 13243 
 13244 static bool
 13245 window_buffer_changed (struct window *w)
 13246 {
 13247   struct buffer *b = XBUFFER (w->contents);
 13248 
 13249   eassert (BUFFER_LIVE_P (b));
 13250 
 13251   return (BUF_SAVE_MODIFF (b) < BUF_MODIFF (b)) != w->last_had_star;
 13252 }
 13253 
 13254 /* True if W has %c or %C in its mode line and mode line should be updated.  */
 13255 
 13256 static bool
 13257 mode_line_update_needed (struct window *w)
 13258 {
 13259   return (w->column_number_displayed != -1
 13260           && !(PT == w->last_point && !window_outdated (w))
 13261           && (w->column_number_displayed != current_column ()));
 13262 }
 13263 
 13264 /* True if window start of W is frozen and may not be changed during
 13265    redisplay.  */
 13266 
 13267 static bool
 13268 window_frozen_p (struct window *w)
 13269 {
 13270   if (FRAME_WINDOWS_FROZEN (XFRAME (WINDOW_FRAME (w))))
 13271     {
 13272       Lisp_Object window;
 13273 
 13274       XSETWINDOW (window, w);
 13275       if (MINI_WINDOW_P (w))
 13276         return false;
 13277       else if (EQ (window, selected_window))
 13278         return false;
 13279       else if (MINI_WINDOW_P (XWINDOW (selected_window))
 13280                && EQ (window, Vminibuf_scroll_window))
 13281         /* This special window can't be frozen too.  */
 13282         return false;
 13283       else
 13284         return true;
 13285     }
 13286   return false;
 13287 }
 13288 
 13289 /***********************************************************************
 13290                      Mode Lines and Frame Titles
 13291  ***********************************************************************/
 13292 
 13293 /* A buffer for constructing non-propertized mode-line strings and
 13294    frame titles in it; allocated from the heap in init_xdisp and
 13295    resized as needed in store_mode_line_noprop_char.  */
 13296 
 13297 static char *mode_line_noprop_buf;
 13298 
 13299 /* The buffer's end, and a current output position in it.  */
 13300 
 13301 static char *mode_line_noprop_buf_end;
 13302 static char *mode_line_noprop_ptr;
 13303 
 13304 #define MODE_LINE_NOPROP_LEN(start) \
 13305   ((mode_line_noprop_ptr - mode_line_noprop_buf) - start)
 13306 
 13307 static enum {
 13308   MODE_LINE_DISPLAY = 0,
 13309   MODE_LINE_TITLE,
 13310   MODE_LINE_NOPROP,
 13311   MODE_LINE_STRING
 13312 } mode_line_target;
 13313 
 13314 /* Alist that caches the results of :propertize.
 13315    Each element is (PROPERTIZED-STRING . PROPERTY-LIST).  */
 13316 static Lisp_Object mode_line_proptrans_alist;
 13317 
 13318 /* List of strings making up the mode-line.  */
 13319 static Lisp_Object mode_line_string_list;
 13320 
 13321 /* Base face property when building propertized mode line string.  */
 13322 static Lisp_Object mode_line_string_face;
 13323 static Lisp_Object mode_line_string_face_prop;
 13324 
 13325 
 13326 /* Unwind data for mode line strings */
 13327 
 13328 static Lisp_Object Vmode_line_unwind_vector;
 13329 
 13330 static Lisp_Object
 13331 format_mode_line_unwind_data (struct frame *target_frame,
 13332                               struct buffer *obuf,
 13333                               Lisp_Object owin,
 13334                               bool save_proptrans)
 13335 {
 13336   Lisp_Object vector, tmp;
 13337 
 13338   /* Reduce consing by keeping one vector in
 13339      Vwith_echo_area_save_vector.  */
 13340   vector = Vmode_line_unwind_vector;
 13341   Vmode_line_unwind_vector = Qnil;
 13342 
 13343   if (NILP (vector))
 13344     vector = make_nil_vector (12);
 13345 
 13346   ASET (vector, 0, make_fixnum (mode_line_target));
 13347   ASET (vector, 1, make_fixnum (MODE_LINE_NOPROP_LEN (0)));
 13348   ASET (vector, 2, mode_line_string_list);
 13349   ASET (vector, 3, save_proptrans ? mode_line_proptrans_alist : Qt);
 13350   ASET (vector, 4, mode_line_string_face);
 13351   ASET (vector, 5, mode_line_string_face_prop);
 13352 
 13353   if (obuf)
 13354     XSETBUFFER (tmp, obuf);
 13355   else
 13356     tmp = Qnil;
 13357   ASET (vector, 6, tmp);
 13358   ASET (vector, 7, owin);
 13359   if (target_frame)
 13360     {
 13361       Lisp_Object buffer = XWINDOW (target_frame->selected_window)->contents;
 13362       struct buffer *b = XBUFFER (buffer);
 13363       struct buffer *cb = current_buffer;
 13364 
 13365       /* Similarly to `with-selected-window', if the operation selects
 13366          a window on another frame, we must restore that frame's
 13367          selected window, and (for a tty) the top-frame.  */
 13368       ASET (vector, 8, target_frame->selected_window);
 13369       if (FRAME_TERMCAP_P (target_frame))
 13370         ASET (vector, 9, FRAME_TTY (target_frame)->top_frame);
 13371 
 13372       /* If we select a window on another frame, make sure that that
 13373          selection does not leave its buffer's point modified when
 13374          unwinding (Bug#32777).  */
 13375       ASET (vector, 10, buffer);
 13376       current_buffer = b;
 13377       ASET (vector, 11, build_marker (current_buffer, PT, PT_BYTE));
 13378       current_buffer = cb;
 13379     }
 13380 
 13381   return vector;
 13382 }
 13383 
 13384 static void
 13385 unwind_format_mode_line (Lisp_Object vector)
 13386 {
 13387   Lisp_Object old_window = AREF (vector, 7);
 13388   Lisp_Object target_frame_window = AREF (vector, 8);
 13389   Lisp_Object old_top_frame = AREF (vector, 9);
 13390 
 13391   mode_line_target = XFIXNUM (AREF (vector, 0));
 13392   mode_line_noprop_ptr = mode_line_noprop_buf + XFIXNUM (AREF (vector, 1));
 13393   mode_line_string_list = AREF (vector, 2);
 13394   if (! EQ (AREF (vector, 3), Qt))
 13395     mode_line_proptrans_alist = AREF (vector, 3);
 13396   mode_line_string_face = AREF (vector, 4);
 13397   mode_line_string_face_prop = AREF (vector, 5);
 13398 
 13399   /* Select window before buffer, since it may change the buffer.  */
 13400   if (WINDOW_LIVE_P (old_window))
 13401     {
 13402       /* If the operation that we are unwinding had selected a window
 13403          on a different frame, reset its frame-selected-window.  For a
 13404          text terminal, reset its top-frame if necessary.  */
 13405       if (WINDOW_LIVE_P (target_frame_window))
 13406         {
 13407           Lisp_Object frame
 13408             = WINDOW_FRAME (XWINDOW (target_frame_window));
 13409 
 13410           if (!EQ (frame, WINDOW_FRAME (XWINDOW (old_window))))
 13411             Fselect_window (target_frame_window, Qt);
 13412 
 13413           if (!NILP (old_top_frame) && !EQ (old_top_frame, frame)
 13414               /* This could've been destroyed during the formatting,
 13415                  possibly because the terminal was deleted.  */
 13416               && FRAME_LIVE_P (XFRAME (old_top_frame)))
 13417             Fselect_frame (old_top_frame, Qt);
 13418         }
 13419 
 13420       Fselect_window (old_window, Qt);
 13421 
 13422       /* Restore point of target_frame_window's buffer (Bug#32777).
 13423          But do this only after old_window has been reselected to
 13424          avoid that the window point of target_frame_window moves.  */
 13425       if (WINDOW_LIVE_P (target_frame_window))
 13426         {
 13427           Lisp_Object buffer = AREF (vector, 10);
 13428 
 13429           if (BUFFER_LIVE_P (XBUFFER (buffer)))
 13430             {
 13431               struct buffer *cb = current_buffer;
 13432 
 13433               current_buffer = XBUFFER (buffer);
 13434               set_point_from_marker (AREF (vector, 11));
 13435               ASET (vector, 11, Qnil);
 13436               current_buffer = cb;
 13437             }
 13438         }
 13439     }
 13440 
 13441   if (!NILP (AREF (vector, 6)))
 13442     {
 13443       set_buffer_internal_1 (XBUFFER (AREF (vector, 6)));
 13444       ASET (vector, 6, Qnil);
 13445     }
 13446 
 13447   Vmode_line_unwind_vector = vector;
 13448 }
 13449 
 13450 
 13451 /* Store a single character C for the frame title in mode_line_noprop_buf.
 13452    Re-allocate mode_line_noprop_buf if necessary.  */
 13453 
 13454 static void
 13455 store_mode_line_noprop_char (char c)
 13456 {
 13457   /* If output position has reached the end of the allocated buffer,
 13458      increase the buffer's size.  */
 13459   if (mode_line_noprop_ptr == mode_line_noprop_buf_end)
 13460     {
 13461       ptrdiff_t len = MODE_LINE_NOPROP_LEN (0);
 13462       ptrdiff_t size = len;
 13463       mode_line_noprop_buf =
 13464         xpalloc (mode_line_noprop_buf, &size, 1, STRING_BYTES_BOUND, 1);
 13465       mode_line_noprop_buf_end = mode_line_noprop_buf + size;
 13466       mode_line_noprop_ptr = mode_line_noprop_buf + len;
 13467     }
 13468 
 13469   *mode_line_noprop_ptr++ = c;
 13470 }
 13471 
 13472 
 13473 /* Store part of a frame title in mode_line_noprop_buf, beginning at
 13474    mode_line_noprop_ptr.  STRING is the string to store.  Do not copy
 13475    characters that yield more columns than PRECISION; PRECISION <= 0
 13476    means copy the whole string.  Pad with spaces until FIELD_WIDTH
 13477    number of characters have been copied; FIELD_WIDTH <= 0 means don't
 13478    pad.  Called from display_mode_element when it is used to build a
 13479    frame title.  */
 13480 
 13481 static int
 13482 store_mode_line_noprop (const char *string, int field_width, int precision)
 13483 {
 13484   const unsigned char *str = (const unsigned char *) string;
 13485   int n = 0;
 13486   ptrdiff_t dummy, nbytes;
 13487 
 13488   /* Copy at most PRECISION chars from STR.  */
 13489   nbytes = strlen (string);
 13490   n += c_string_width (str, nbytes, precision, &dummy, &nbytes);
 13491   while (nbytes--)
 13492     store_mode_line_noprop_char (*str++);
 13493 
 13494   /* Fill up with spaces until FIELD_WIDTH reached.  */
 13495   while (field_width > 0
 13496          && n < field_width)
 13497     {
 13498       store_mode_line_noprop_char (' ');
 13499       ++n;
 13500     }
 13501 
 13502   return n;
 13503 }
 13504 
 13505 /***********************************************************************
 13506                              Frame Titles
 13507  ***********************************************************************/
 13508 
 13509 #ifdef HAVE_WINDOW_SYSTEM
 13510 
 13511 /* Set the title of FRAME, if it has changed.  The title format is
 13512    Vicon_title_format if FRAME is iconified, otherwise it is
 13513    frame_title_format.  */
 13514 
 13515 void
 13516 gui_consider_frame_title (Lisp_Object frame)
 13517 {
 13518   struct frame *f = XFRAME (frame);
 13519   Lisp_Object format_data;
 13520 
 13521   if ((FRAME_WINDOW_P (f)
 13522        || FRAME_MINIBUF_ONLY_P (f)
 13523        || f->explicit_name)
 13524       && !FRAME_TOOLTIP_P (f))
 13525     {
 13526       /* Do we have more than one visible frame on this X display?  */
 13527       Lisp_Object tail, other_frame, fmt;
 13528       ptrdiff_t title_start;
 13529       char *title;
 13530       ptrdiff_t len;
 13531       struct it it;
 13532       specpdl_ref count = SPECPDL_INDEX ();
 13533 
 13534       FOR_EACH_FRAME (tail, other_frame)
 13535         {
 13536           struct frame *tf = XFRAME (other_frame);
 13537 
 13538           if (tf != f
 13539               && FRAME_KBOARD (tf) == FRAME_KBOARD (f)
 13540               && !FRAME_MINIBUF_ONLY_P (tf)
 13541               && !FRAME_PARENT_FRAME (tf)
 13542               && !FRAME_TOOLTIP_P (tf)
 13543               && (FRAME_VISIBLE_P (tf) || FRAME_ICONIFIED_P (tf)))
 13544             break;
 13545         }
 13546 
 13547       /* Set global variable indicating that multiple frames exist.  */
 13548       multiple_frames = CONSP (tail);
 13549 
 13550       /* select-frame calls resize_mini_window, which could resize the
 13551          mini-window and by that undo the effect of this redisplay
 13552          cycle wrt minibuffer and echo-area display.  Binding
 13553          inhibit-redisplay to t makes the call to resize_mini_window a
 13554          no-op, thus avoiding the adverse side effects.  */
 13555 
 13556       /* The following was moved before the record_unwind_protect form
 13557          below to inhibit redisplay also when restoring the selected
 13558          window/frame: This avoids that resize_mini_window sizes back
 13559          the minibuffer window of a temporarily selected frame.  See
 13560          Bug#34317.  */
 13561       specbind (Qinhibit_redisplay, Qt);
 13562 
 13563       /* Switch to the buffer of selected window of the frame.  Set up
 13564          mode_line_target so that display_mode_element will output
 13565          into mode_line_noprop_buf; then display the title.  Save the
 13566          original frame and selected window, and possibly the topmost
 13567          frame of the tty (for tty frames) into a vector; it will be
 13568          restored later.  */
 13569 
 13570       format_data = format_mode_line_unwind_data (f, current_buffer,
 13571                                                   selected_window,
 13572                                                   false);
 13573       record_unwind_protect (unwind_format_mode_line, format_data);
 13574 
 13575       Fselect_window (f->selected_window, Qt);
 13576       set_buffer_internal_1 (XBUFFER (XWINDOW (f->selected_window)->contents));
 13577       fmt = (FRAME_ICONIFIED_P (f) && !EQ (Vicon_title_format, Qt)
 13578              ? Vicon_title_format : Vframe_title_format);
 13579 
 13580       mode_line_target = MODE_LINE_TITLE;
 13581       title_start = MODE_LINE_NOPROP_LEN (0);
 13582       init_iterator (&it, XWINDOW (f->selected_window), -1, -1,
 13583                      NULL, DEFAULT_FACE_ID);
 13584       display_mode_element (&it, 0, -1, -1, fmt, Qnil, false);
 13585       len = MODE_LINE_NOPROP_LEN (title_start);
 13586       title = mode_line_noprop_buf + title_start;
 13587       /* Make sure that any raw bytes in the title are properly
 13588          represented by their multibyte sequences.  */
 13589       ptrdiff_t nchars = 0;
 13590       len = str_as_multibyte ((unsigned char *) title,
 13591                               mode_line_noprop_buf_end - title,
 13592                               len, &nchars);
 13593       unbind_to (count, Qnil);
 13594 
 13595       /* Set the title only if it's changed.  This avoids consing in
 13596          the common case where it hasn't.  (If it turns out that we've
 13597          already wasted too much time by walking through the list with
 13598          display_mode_element, then we might need to optimize at a
 13599          higher level than this.)  */
 13600       if ((! STRINGP (f->name)
 13601            || SBYTES (f->name) != len
 13602            || memcmp (title, SDATA (f->name), len) != 0)
 13603           && FRAME_TERMINAL (f)->implicit_set_name_hook)
 13604         {
 13605           Lisp_Object title_string = make_multibyte_string (title, nchars, len);
 13606           FRAME_TERMINAL (f)->implicit_set_name_hook (f, title_string, Qnil);
 13607         }
 13608     }
 13609 }
 13610 
 13611 #endif /* not HAVE_WINDOW_SYSTEM */
 13612 
 13613 
 13614 /***********************************************************************
 13615                               Menu Bars
 13616  ***********************************************************************/
 13617 
 13618 /* True if we will not redisplay all visible windows.  */
 13619 #define REDISPLAY_SOME_P()                              \
 13620   ((windows_or_buffers_changed == 0                     \
 13621     || windows_or_buffers_changed == REDISPLAY_SOME)    \
 13622    && (update_mode_lines == 0                           \
 13623        || update_mode_lines == REDISPLAY_SOME))
 13624 
 13625 static bool
 13626 needs_no_redisplay (struct window *w)
 13627 {
 13628   struct buffer *buffer = XBUFFER (w->contents);
 13629   struct frame *f = XFRAME (w->frame);
 13630   return (REDISPLAY_SOME_P ()
 13631           && !w->redisplay
 13632           && !w->update_mode_line
 13633           && !f->face_change
 13634           && !f->redisplay
 13635           && !buffer->text->redisplay
 13636           && window_point (w) == w->last_point);
 13637 }
 13638 
 13639 /* Prepare for redisplay by updating menu-bar item lists when
 13640    appropriate.  This can call eval.  */
 13641 
 13642 static void
 13643 prepare_menu_bars (void)
 13644 {
 13645   bool all_windows = windows_or_buffers_changed || update_mode_lines;
 13646   bool some_windows = REDISPLAY_SOME_P ();
 13647 
 13648   if (FUNCTIONP (Vpre_redisplay_function))
 13649     {
 13650       Lisp_Object windows = all_windows ? Qt : Qnil;
 13651       if (all_windows && some_windows)
 13652         {
 13653           Lisp_Object ws = window_list ();
 13654           for (windows = Qnil; CONSP (ws); ws = XCDR (ws))
 13655             {
 13656               Lisp_Object this = XCAR (ws);
 13657               struct window *w = XWINDOW (this);
 13658               /* Cf. conditions for redisplaying a window at the
 13659                  beginning of redisplay_window.  */
 13660               if (!needs_no_redisplay (w))
 13661                 windows = Fcons (this, windows);
 13662             }
 13663         }
 13664       safe__call1 (true, Vpre_redisplay_function, windows);
 13665     }
 13666 
 13667   /* Update all frame titles based on their buffer names, etc.  We do
 13668      this before the menu bars so that the buffer-menu will show the
 13669      up-to-date frame titles.  */
 13670 #ifdef HAVE_WINDOW_SYSTEM
 13671   if (all_windows)
 13672     {
 13673       Lisp_Object tail, frame;
 13674 
 13675       FOR_EACH_FRAME (tail, frame)
 13676         {
 13677           struct frame *f = XFRAME (frame);
 13678           struct window *w = XWINDOW (FRAME_SELECTED_WINDOW (f));
 13679           if (some_windows
 13680               && !f->redisplay
 13681               && !w->redisplay
 13682               && !XBUFFER (w->contents)->text->redisplay)
 13683             continue;
 13684 
 13685           if (!FRAME_TOOLTIP_P (f)
 13686               && (FRAME_ICONIFIED_P (f)
 13687                   || FRAME_VISIBLE_P (f) == 1
 13688                   /* Exclude TTY frames that are obscured because they
 13689                      are not the top frame on their console.  This is
 13690                      because gui_consider_frame_title actually switches
 13691                      to the frame, which for TTY frames means it is
 13692                      marked as garbaged, and will be completely
 13693                      redrawn on the next redisplay cycle.  This causes
 13694                      TTY frames to be completely redrawn, when there
 13695                      are more than one of them, even though nothing
 13696                      should be changed on display.  */
 13697                   || (FRAME_REDISPLAY_P (f) && FRAME_WINDOW_P (f))))
 13698             gui_consider_frame_title (frame);
 13699         }
 13700     }
 13701 #endif /* HAVE_WINDOW_SYSTEM */
 13702 
 13703   /* Update the menu bar item lists, if appropriate.  This has to be
 13704      done before any actual redisplay or generation of display lines.  */
 13705 
 13706   if (all_windows)
 13707     {
 13708       Lisp_Object tail, frame;
 13709       specpdl_ref count = SPECPDL_INDEX ();
 13710       /* True means that update_menu_bar has run its hooks
 13711          so any further calls to update_menu_bar shouldn't do so again.  */
 13712       bool menu_bar_hooks_run = false;
 13713 
 13714       record_unwind_save_match_data ();
 13715 
 13716       FOR_EACH_FRAME (tail, frame)
 13717         {
 13718           struct frame *f = XFRAME (frame);
 13719           struct window *w = XWINDOW (FRAME_SELECTED_WINDOW (f));
 13720 
 13721           /* Ignore tooltip frame.  */
 13722           if (FRAME_TOOLTIP_P (f))
 13723             continue;
 13724 
 13725           if (some_windows
 13726               && !f->redisplay
 13727               && !w->redisplay
 13728               && !XBUFFER (w->contents)->text->redisplay)
 13729             continue;
 13730 
 13731           if (!FRAME_PARENT_FRAME (f))
 13732             menu_bar_hooks_run = update_menu_bar (f, false, menu_bar_hooks_run);
 13733 
 13734           update_tab_bar (f, false);
 13735 #ifdef HAVE_WINDOW_SYSTEM
 13736           update_tool_bar (f, false);
 13737 #endif
 13738         }
 13739 
 13740       unbind_to (count, Qnil);
 13741     }
 13742   else
 13743     {
 13744       struct frame *sf = SELECTED_FRAME ();
 13745 
 13746       if (!FRAME_PARENT_FRAME (sf))
 13747         update_menu_bar (sf, true, false);
 13748 
 13749       update_tab_bar (sf, true);
 13750 #ifdef HAVE_WINDOW_SYSTEM
 13751       update_tool_bar (sf, true);
 13752 #endif
 13753     }
 13754 }
 13755 
 13756 
 13757 /* Update the menu bar item list for frame F.  This has to be done
 13758    before we start to fill in any display lines, because it can call
 13759    eval.
 13760 
 13761    If SAVE_MATCH_DATA, we must save and restore it here.
 13762 
 13763    If HOOKS_RUN, a previous call to update_menu_bar
 13764    already ran the menu bar hooks for this redisplay, so there
 13765    is no need to run them again.  The return value is the
 13766    updated value of this flag, to pass to the next call.  */
 13767 
 13768 static bool
 13769 update_menu_bar (struct frame *f, bool save_match_data, bool hooks_run)
 13770 {
 13771   Lisp_Object window;
 13772   struct window *w;
 13773 
 13774   /* If called recursively during a menu update, do nothing.  This can
 13775      happen when, for instance, an activate-menubar-hook causes a
 13776      redisplay.  */
 13777   if (inhibit_menubar_update)
 13778     return hooks_run;
 13779 
 13780   window = FRAME_SELECTED_WINDOW (f);
 13781   w = XWINDOW (window);
 13782 
 13783   if (FRAME_WINDOW_P (f)
 13784       ?
 13785 #ifdef HAVE_EXT_MENU_BAR
 13786       FRAME_EXTERNAL_MENU_BAR (f)
 13787 #else
 13788       FRAME_MENU_BAR_LINES (f) > 0
 13789 #endif
 13790       : FRAME_MENU_BAR_LINES (f) > 0)
 13791     {
 13792       /* If the user has switched buffers or windows, we need to
 13793          recompute to reflect the new bindings.  But we'll
 13794          recompute when update_mode_lines is set too; that means
 13795          that people can use force-mode-line-update to request
 13796          that the menu bar be recomputed.  The adverse effect on
 13797          the rest of the redisplay algorithm is about the same as
 13798          windows_or_buffers_changed anyway.  */
 13799       if (windows_or_buffers_changed
 13800           /* This used to test w->update_mode_line, but we believe
 13801              there is no need to recompute the menu in that case.  */
 13802           || update_mode_lines
 13803           || window_buffer_changed (w))
 13804         {
 13805           struct buffer *prev = current_buffer;
 13806           specpdl_ref count = SPECPDL_INDEX ();
 13807 
 13808           specbind (Qinhibit_menubar_update, Qt);
 13809 
 13810           set_buffer_internal_1 (XBUFFER (w->contents));
 13811           if (save_match_data)
 13812             record_unwind_save_match_data ();
 13813           if (NILP (Voverriding_local_map_menu_flag))
 13814             {
 13815               specbind (Qoverriding_terminal_local_map, Qnil);
 13816               specbind (Qoverriding_local_map, Qnil);
 13817             }
 13818 
 13819           if (!hooks_run)
 13820             {
 13821               /* Run the Lucid hook.  */
 13822               safe_run_hooks (Qactivate_menubar_hook);
 13823 
 13824               /* If it has changed current-menubar from previous value,
 13825                  really recompute the menu-bar from the value.  */
 13826               safe_run_hooks (Qmenu_bar_update_hook);
 13827 
 13828               hooks_run = true;
 13829             }
 13830 
 13831           XSETFRAME (Vmenu_updating_frame, f);
 13832           fset_menu_bar_items (f, menu_bar_items (FRAME_MENU_BAR_ITEMS (f)));
 13833 
 13834           /* Redisplay the menu bar in case we changed it.  */
 13835 #ifdef HAVE_EXT_MENU_BAR
 13836           if (FRAME_WINDOW_P (f))
 13837             {
 13838 #if defined (HAVE_NS)
 13839               /* All frames on Mac OS share the same menubar.  So only
 13840                  the selected frame should be allowed to set it.  */
 13841               if (f == SELECTED_FRAME ())
 13842 #endif
 13843                 set_frame_menubar (f, false);
 13844             }
 13845           else
 13846             /* On a terminal screen, the menu bar is an ordinary screen
 13847                line, and this makes it get updated.  */
 13848             w->update_mode_line = true;
 13849 #else /* ! (HAVE_EXT_MENU_BAR) */
 13850           /* In the non-toolkit version, the menu bar is an ordinary screen
 13851              line, and this makes it get updated.  */
 13852           w->update_mode_line = true;
 13853 #endif /* HAVE_EXT_MENU_BAR */
 13854 
 13855           unbind_to (count, Qnil);
 13856           set_buffer_internal_1 (prev);
 13857         }
 13858     }
 13859 
 13860   return hooks_run;
 13861 }
 13862 
 13863 
 13864 
 13865 /***********************************************************************
 13866                                Tab-bars
 13867  ***********************************************************************/
 13868 
 13869 /* Restore WINDOW as the selected window and its frame as the selected
 13870    frame.  If WINDOW is dead but the selected frame is live, make the
 13871    latter's selected window the selected window.  If both, WINDOW and
 13872    the selected frame, are dead, assign selected frame and window from
 13873    some arbitrary live frame.  Abort if no such frame can be found.  */
 13874 static void
 13875 restore_selected_window (Lisp_Object window)
 13876 {
 13877   if (WINDOW_LIVE_P (window))
 13878     /* If WINDOW is live, make it the selected window and its frame's
 13879        selected window and set the selected frame to its frame.  */
 13880     {
 13881       selected_window = window;
 13882       selected_frame = XWINDOW (window)->frame;
 13883       FRAME_SELECTED_WINDOW (XFRAME (selected_frame)) = window;
 13884     }
 13885   else if (FRAMEP (selected_frame) && FRAME_LIVE_P (XFRAME (selected_frame)))
 13886     /* If WINDOW is dead but the selected frame is still live, make the
 13887        latter's selected window the selected one.  */
 13888     selected_window = FRAME_SELECTED_WINDOW (XFRAME (selected_frame));
 13889   else
 13890     /* If WINDOW and the selected frame are dead, choose some live,
 13891        non-child and non-tooltip frame as the new selected frame and
 13892        make its selected window the selected window.  */
 13893     {
 13894       Lisp_Object tail;
 13895       Lisp_Object frame UNINIT;
 13896 
 13897       FOR_EACH_FRAME (tail, frame)
 13898         {
 13899           struct frame *f = XFRAME (frame);
 13900 
 13901           if (!FRAME_PARENT_FRAME (f) && !FRAME_TOOLTIP_P (f))
 13902             {
 13903               selected_frame = frame;
 13904               selected_window = FRAME_SELECTED_WINDOW (f);
 13905 
 13906               return;
 13907             }
 13908         }
 13909 
 13910       /* Abort if we cannot find a live frame.  */
 13911       emacs_abort ();
 13912     }
 13913 }
 13914 
 13915 /* Restore WINDOW, if live, as its frame's selected window.  */
 13916 static void
 13917 restore_frame_selected_window (Lisp_Object window)
 13918 {
 13919   if (WINDOW_LIVE_P (window))
 13920     /* If WINDOW is live, make it its frame's selected window.  If that
 13921        frame is the selected frame, make WINDOW the selected window as
 13922        well.  */
 13923     {
 13924       Lisp_Object frame = XWINDOW (window)->frame;
 13925 
 13926       FRAME_SELECTED_WINDOW (XFRAME (frame)) = window;
 13927       if (EQ (frame, selected_frame))
 13928         selected_window = window;
 13929     }
 13930 }
 13931 
 13932 /* Update the tab-bar item list for frame F.  This has to be done
 13933    before we start to fill in any display lines.  Called from
 13934    prepare_menu_bars.  If SAVE_MATCH_DATA, we must save
 13935    and restore it here.  */
 13936 
 13937 static void
 13938 update_tab_bar (struct frame *f, bool save_match_data)
 13939 {
 13940   bool do_update = false;
 13941 
 13942 #ifdef HAVE_WINDOW_SYSTEM
 13943   if (FRAME_WINDOW_P (f) && WINDOWP (f->tab_bar_window)) {
 13944     if (WINDOW_TOTAL_LINES (XWINDOW (f->tab_bar_window)) > 0)
 13945       do_update = true;
 13946   }
 13947   else
 13948 #endif
 13949   if (FRAME_TAB_BAR_LINES (f) > 0)
 13950     do_update = true;
 13951 
 13952   if (do_update)
 13953     {
 13954       Lisp_Object window;
 13955       struct window *w;
 13956 
 13957       window = FRAME_SELECTED_WINDOW (f);
 13958       w = XWINDOW (window);
 13959 
 13960       /* If the user has switched buffers or windows, we need to
 13961          recompute to reflect the new bindings.  But we'll
 13962          recompute when update_mode_lines is set too; that means
 13963          that people can use force-mode-line-update to request
 13964          that the menu bar be recomputed.  The adverse effect on
 13965          the rest of the redisplay algorithm is about the same as
 13966          windows_or_buffers_changed anyway.  */
 13967       if (windows_or_buffers_changed
 13968           || w->update_mode_line
 13969           || update_mode_lines
 13970           || window_buffer_changed (w))
 13971         {
 13972           struct buffer *prev = current_buffer;
 13973           specpdl_ref count = SPECPDL_INDEX ();
 13974           Lisp_Object new_tab_bar;
 13975           int new_n_tab_bar;
 13976 
 13977           /* Set current_buffer to the buffer of the selected
 13978              window of the frame, so that we get the right local
 13979              keymaps.  */
 13980           set_buffer_internal_1 (XBUFFER (w->contents));
 13981 
 13982           /* Save match data, if we must.  */
 13983           if (save_match_data)
 13984             record_unwind_save_match_data ();
 13985 
 13986           /* Make sure that we don't accidentally use bogus keymaps.  */
 13987           if (NILP (Voverriding_local_map_menu_flag))
 13988             {
 13989               specbind (Qoverriding_terminal_local_map, Qnil);
 13990               specbind (Qoverriding_local_map, Qnil);
 13991             }
 13992 
 13993           /* We must temporarily set the selected frame to this frame
 13994              before calling tab_bar_items, because the calculation of
 13995              the tab-bar keymap uses the selected frame (see
 13996              `tab-bar-make-keymap' in tab-bar.el).  */
 13997           eassert (EQ (selected_window,
 13998                        /* Since we only explicitly preserve selected_frame,
 13999                           check that selected_window would be redundant.  */
 14000                        XFRAME (selected_frame)->selected_window));
 14001 #ifdef HAVE_WINDOW_SYSTEM
 14002           Lisp_Object frame;
 14003           record_unwind_protect (restore_selected_window, selected_window);
 14004           XSETFRAME (frame, f);
 14005           selected_frame = frame;
 14006           selected_window = FRAME_SELECTED_WINDOW (f);
 14007 #endif
 14008 
 14009           /* Build desired tab-bar items from keymaps.  */
 14010           new_tab_bar
 14011             = tab_bar_items (Fcopy_sequence (f->tab_bar_items),
 14012                               &new_n_tab_bar);
 14013 
 14014           /* Redisplay the tab-bar if we changed it.  */
 14015           if (new_n_tab_bar != f->n_tab_bar_items
 14016               || NILP (Fequal (new_tab_bar, f->tab_bar_items)))
 14017             {
 14018               /* Redisplay that happens asynchronously due to an expose event
 14019                  may access f->tab_bar_items.  Make sure we update both
 14020                  variables within BLOCK_INPUT so no such event interrupts.  */
 14021               block_input ();
 14022               fset_tab_bar_items (f, new_tab_bar);
 14023               f->n_tab_bar_items = new_n_tab_bar;
 14024               w->update_mode_line = true;
 14025               unblock_input ();
 14026             }
 14027 
 14028           unbind_to (count, Qnil);
 14029           set_buffer_internal_1 (prev);
 14030         }
 14031     }
 14032 }
 14033 
 14034 /* Redisplay the tab bar in the frame for window W.
 14035 
 14036    The tab bar of X frames that don't have X toolkit support is
 14037    displayed in a special window W->frame->tab_bar_window.
 14038 
 14039    The tab bar of terminal frames is treated specially as far as
 14040    glyph matrices are concerned.  Tab bar lines are not part of
 14041    windows, so the update is done directly on the frame matrix rows
 14042    for the tab bar.  */
 14043 
 14044 static void
 14045 display_tab_bar (struct window *w)
 14046 {
 14047   struct frame *f = XFRAME (WINDOW_FRAME (w));
 14048   struct it it;
 14049   Lisp_Object items;
 14050   int i;
 14051 
 14052   /* Don't do all this for graphical frames.  */
 14053 #ifdef HAVE_NTGUI
 14054   if (FRAME_W32_P (f))
 14055     return;
 14056 #endif
 14057 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
 14058   if (FRAME_X_P (f))
 14059     return;
 14060 #endif
 14061 
 14062 #ifdef HAVE_NS
 14063   if (FRAME_NS_P (f))
 14064     return;
 14065 #endif /* HAVE_NS */
 14066 
 14067 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
 14068   eassert (!FRAME_WINDOW_P (f));
 14069   init_iterator (&it, w, -1, -1, f->desired_matrix->rows
 14070                  + (FRAME_MENU_BAR_LINES (f) > 0 ? 1 : 0),
 14071                  TAB_BAR_FACE_ID);
 14072   it.first_visible_x = 0;
 14073   it.last_visible_x = FRAME_PIXEL_WIDTH (f);
 14074 #elif defined (HAVE_X_WINDOWS) /* X without toolkit.  */
 14075   if (FRAME_WINDOW_P (f))
 14076     {
 14077       /* Tab bar lines are displayed in the desired matrix of the
 14078          dummy window tab_bar_window.  */
 14079       struct window *tab_w;
 14080       tab_w = XWINDOW (f->tab_bar_window);
 14081       init_iterator (&it, tab_w, -1, -1, tab_w->desired_matrix->rows,
 14082                      TAB_BAR_FACE_ID);
 14083       it.first_visible_x = 0;
 14084       it.last_visible_x = FRAME_PIXEL_WIDTH (f);
 14085     }
 14086   else
 14087 #endif /* not USE_X_TOOLKIT and not USE_GTK */
 14088     {
 14089       /* This is a TTY frame, i.e. character hpos/vpos are used as
 14090          pixel x/y.  */
 14091       init_iterator (&it, w, -1, -1, f->desired_matrix->rows
 14092                      + (FRAME_MENU_BAR_LINES (f) > 0 ? 1 : 0),
 14093                      TAB_BAR_FACE_ID);
 14094       it.first_visible_x = 0;
 14095       it.last_visible_x = FRAME_COLS (f);
 14096     }
 14097 
 14098   /* FIXME: This should be controlled by a user option.  See the
 14099      comments in redisplay_tool_bar and display_mode_line about
 14100      this.  */
 14101   it.paragraph_embedding = L2R;
 14102 
 14103   /* Clear all rows of the tab bar.  */
 14104   for (i = 0; i < FRAME_TAB_BAR_LINES (f); ++i)
 14105     {
 14106       struct glyph_row *row = it.glyph_row + i;
 14107       clear_glyph_row (row);
 14108       row->enabled_p = true;
 14109       row->full_width_p = true;
 14110       row->reversed_p = false;
 14111     }
 14112 
 14113   /* Display all items of the tab bar.  */
 14114   items = it.f->tab_bar_items;
 14115   int j;
 14116   for (i = 0, j = 0; i < it.f->n_tab_bar_items; ++i, j += TAB_BAR_ITEM_NSLOTS)
 14117     {
 14118       Lisp_Object string = AREF (items, j + TAB_BAR_ITEM_CAPTION);
 14119 
 14120       /* Stop at nil string.  */
 14121       if (NILP (string))
 14122         break;
 14123 
 14124       if (it.current_x < it.last_visible_x)
 14125         display_string (NULL, string, Qnil, 0, 0, &it,
 14126                         SCHARS (string), 0, 0, STRING_MULTIBYTE (string));
 14127     }
 14128 
 14129   /* Fill out the line with spaces.  */
 14130   if (it.current_x < it.last_visible_x)
 14131     display_string ("", Qnil, Qnil, 0, 0, &it, -1, 0, 0, -1);
 14132 
 14133   /* Compute the total height of the lines.  */
 14134   compute_line_metrics (&it);
 14135 }
 14136 
 14137 #ifdef HAVE_WINDOW_SYSTEM
 14138 
 14139 /* Set F->desired_tab_bar_string to a Lisp string representing frame
 14140    F's desired tab-bar contents.  F->tab_bar_items must have
 14141    been set up previously by calling prepare_menu_bars.  */
 14142 
 14143 static void
 14144 build_desired_tab_bar_string (struct frame *f)
 14145 {
 14146   int i;
 14147   Lisp_Object caption;
 14148 
 14149   caption = Qnil;
 14150 
 14151   /* Prepare F->desired_tab_bar_string.  Make a new string.  */
 14152   fset_desired_tab_bar_string (f, build_string (""));
 14153 
 14154   /* Put a `display' property on the string for the captions to display,
 14155      put a `menu_item' property on tab-bar items with a value that
 14156      is the index of the item in F's tab-bar item vector.  */
 14157   for (i = 0; i < f->n_tab_bar_items; ++i)
 14158     {
 14159 #define PROP(IDX) \
 14160   AREF (f->tab_bar_items, i * TAB_BAR_ITEM_NSLOTS + (IDX))
 14161 
 14162       caption = Fcopy_sequence (PROP (TAB_BAR_ITEM_CAPTION));
 14163 
 14164       /* Put a `display' text property on the string for the caption to
 14165          display.  Put a `menu-item' property on the string that gives
 14166          the start of this item's properties in the tab-bar items
 14167          vector.  */
 14168       AUTO_LIST2 (props, Qmenu_item, make_fixnum (i * TAB_BAR_ITEM_NSLOTS));
 14169 
 14170       Fadd_text_properties (make_fixnum (0), make_fixnum (SCHARS (caption)),
 14171                             props, caption);
 14172 
 14173       f->desired_tab_bar_string =
 14174         concat2 (f->desired_tab_bar_string, caption);
 14175 
 14176 #undef PROP
 14177     }
 14178 }
 14179 
 14180 
 14181 /* Display one line of the tab-bar of frame IT->f.
 14182 
 14183    HEIGHT specifies the desired height of the tab-bar line.
 14184    If the actual height of the glyph row is less than HEIGHT, the
 14185    row's height is increased to HEIGHT, and the icons are centered
 14186    vertically in the new height.
 14187 
 14188    If HEIGHT is -1, we are counting needed tab-bar lines, so don't
 14189    count a final empty row in case the tab-bar width exactly matches
 14190    the window width.
 14191 */
 14192 
 14193 static void
 14194 display_tab_bar_line (struct it *it, int height)
 14195 {
 14196   struct glyph_row *row = it->glyph_row;
 14197   int max_x = it->last_visible_x;
 14198   struct glyph *last;
 14199 
 14200   /* Don't extend on a previously drawn tab bar items (Bug#16058).  */
 14201   clear_glyph_row (row);
 14202   row->enabled_p = true;
 14203   row->y = it->current_y;
 14204 
 14205   /* Note that this isn't made use of if the face hasn't a box,
 14206      so there's no need to check the face here.  */
 14207   it->start_of_box_run_p = true;
 14208 
 14209   bool enough = false;
 14210   while (it->current_x < max_x)
 14211     {
 14212       int x, n_glyphs_before, i, nglyphs;
 14213       struct it it_before;
 14214 
 14215       /* Get the next display element.  */
 14216       if (!get_next_display_element (it))
 14217         {
 14218           /* Don't count empty row if we are counting needed tab-bar lines.  */
 14219           if (height < 0 && !it->hpos)
 14220             return;
 14221           break;
 14222         }
 14223 
 14224       /* Produce glyphs.  */
 14225       n_glyphs_before = row->used[TEXT_AREA];
 14226       it_before = *it;
 14227 
 14228       PRODUCE_GLYPHS (it);
 14229 
 14230       nglyphs = row->used[TEXT_AREA] - n_glyphs_before;
 14231       i = 0;
 14232       x = it_before.current_x;
 14233       while (i < nglyphs)
 14234         {
 14235           struct glyph *glyph = row->glyphs[TEXT_AREA] + n_glyphs_before + i;
 14236 
 14237           if (x + glyph->pixel_width > max_x)
 14238             {
 14239               /* Glyph doesn't fit on line.  Backtrack.  */
 14240               row->used[TEXT_AREA] = n_glyphs_before;
 14241               *it = it_before;
 14242               /* If this is the only glyph on this line, it will never fit on the
 14243                  tab-bar, so skip it.  But ensure there is at least one glyph,
 14244                  so we don't accidentally disable the tab-bar.  */
 14245               if (n_glyphs_before == 0
 14246                   && (it->vpos > 0 || IT_STRING_CHARPOS (*it) < it->end_charpos-1))
 14247                 break;
 14248               goto out;
 14249             }
 14250 
 14251           ++it->hpos;
 14252           x += glyph->pixel_width;
 14253           ++i;
 14254         }
 14255 
 14256       enough = ITERATOR_AT_END_OF_LINE_P (it);
 14257       set_iterator_to_next (it, true);
 14258 
 14259       /* Stop at line end.  */
 14260       if (enough)
 14261         break;
 14262     }
 14263 
 14264  out:;
 14265 
 14266   row->displays_text_p = row->used[TEXT_AREA] != 0;
 14267 
 14268   /* Use default face for the border below the tab bar.
 14269 
 14270      FIXME: When auto-resize-tab-bars is grow-only, there is
 14271      no additional border below the possibly empty tab-bar lines.
 14272      So to make the extra empty lines look "normal", we have to
 14273      use the tab-bar face for the border too.  */
 14274   if (!MATRIX_ROW_DISPLAYS_TEXT_P (row)
 14275       && !EQ (Vauto_resize_tab_bars, Qgrow_only))
 14276     it->face_id = DEFAULT_FACE_ID;
 14277 
 14278   extend_face_to_end_of_line (it);
 14279   last = row->glyphs[TEXT_AREA] + row->used[TEXT_AREA] - 1;
 14280   last->right_box_line_p = true;
 14281   if (last == row->glyphs[TEXT_AREA])
 14282     last->left_box_line_p = true;
 14283 
 14284   /* Make line the desired height and center it vertically.  */
 14285   if ((height -= it->max_ascent + it->max_descent) > 0)
 14286     {
 14287       /* Don't add more than one line height.  */
 14288       height %= FRAME_LINE_HEIGHT (it->f);
 14289       it->max_ascent += height / 2;
 14290       it->max_descent += (height + 1) / 2;
 14291     }
 14292 
 14293   compute_line_metrics (it);
 14294 
 14295   /* If line is empty, make it occupy the rest of the tab-bar.  */
 14296   if (!MATRIX_ROW_DISPLAYS_TEXT_P (row))
 14297     {
 14298       row->height = row->phys_height = it->last_visible_y - row->y;
 14299       row->visible_height = row->height;
 14300       row->ascent = row->phys_ascent = 0;
 14301       row->extra_line_spacing = 0;
 14302     }
 14303 
 14304   row->full_width_p = true;
 14305   row->continued_p = false;
 14306   row->truncated_on_left_p = false;
 14307   row->truncated_on_right_p = false;
 14308 
 14309   it->current_x = it->hpos = 0;
 14310   it->current_y += row->height;
 14311   ++it->vpos;
 14312   ++it->glyph_row;
 14313 }
 14314 
 14315 
 14316 /* Value is the number of pixels needed to make all tab-bar items of
 14317    frame F visible.  The actual number of glyph rows needed is
 14318    returned in *N_ROWS if non-NULL.  */
 14319 static int
 14320 tab_bar_height (struct frame *f, int *n_rows, bool pixelwise)
 14321 {
 14322   struct window *w = XWINDOW (f->tab_bar_window);
 14323   struct it it;
 14324   /* tab_bar_height is called from redisplay_tab_bar after building
 14325      the desired matrix, so use (unused) mode-line row as temporary row to
 14326      avoid destroying the first tab-bar row.  */
 14327   struct glyph_row *temp_row = MATRIX_MODE_LINE_ROW (w->desired_matrix);
 14328 
 14329   /* Initialize an iterator for iteration over
 14330      F->desired_tab_bar_string in the tab-bar window of frame F.  */
 14331   init_iterator (&it, w, -1, -1, temp_row, TAB_BAR_FACE_ID);
 14332   temp_row->reversed_p = false;
 14333   it.first_visible_x = 0;
 14334   it.last_visible_x = WINDOW_PIXEL_WIDTH (w);
 14335   reseat_to_string (&it, NULL, f->desired_tab_bar_string,
 14336                     0, 0, 0, STRING_MULTIBYTE (f->desired_tab_bar_string));
 14337   it.paragraph_embedding = L2R;
 14338 
 14339   clear_glyph_row (temp_row);
 14340   while (!ITERATOR_AT_END_P (&it))
 14341     {
 14342       it.glyph_row = temp_row;
 14343       display_tab_bar_line (&it, -1);
 14344     }
 14345   clear_glyph_row (temp_row);
 14346 
 14347   /* f->n_tab_bar_rows == 0 means "unknown"; -1 means no tab-bar.  */
 14348   if (n_rows)
 14349     *n_rows = it.vpos > 0 ? it.vpos : -1;
 14350 
 14351   if (pixelwise)
 14352     return it.current_y;
 14353   else
 14354     return (it.current_y + FRAME_LINE_HEIGHT (f) - 1) / FRAME_LINE_HEIGHT (f);
 14355 }
 14356 
 14357 DEFUN ("tab-bar-height", Ftab_bar_height, Stab_bar_height,
 14358        0, 2, 0,
 14359        doc: /* Return the number of lines occupied by the tab bar of FRAME.
 14360 If FRAME is nil or omitted, use the selected frame.  Optional argument
 14361 PIXELWISE non-nil means return the height of the tab bar in pixels.  */)
 14362   (Lisp_Object frame, Lisp_Object pixelwise)
 14363 {
 14364   int height = 0;
 14365 
 14366   struct frame *f = decode_any_frame (frame);
 14367 
 14368   if (WINDOWP (f->tab_bar_window)
 14369       && WINDOW_PIXEL_HEIGHT (XWINDOW (f->tab_bar_window)) > 0)
 14370     {
 14371       update_tab_bar (f, true);
 14372       if (f->n_tab_bar_items)
 14373         {
 14374           build_desired_tab_bar_string (f);
 14375           height = tab_bar_height (f, NULL, !NILP (pixelwise));
 14376         }
 14377     }
 14378 
 14379   return make_fixnum (height);
 14380 }
 14381 
 14382 
 14383 /* Display the tab-bar of frame F.  Value is true if tab-bar's
 14384    height should be changed.  */
 14385 static bool
 14386 redisplay_tab_bar (struct frame *f)
 14387 {
 14388   struct window *w;
 14389   struct it it;
 14390   struct glyph_row *row;
 14391 
 14392   f->tab_bar_redisplayed = true;
 14393 
 14394   /* If frame hasn't a tab-bar window or if it is zero-height, don't
 14395      do anything.  This means you must start with tab-bar-lines
 14396      non-zero to get the auto-sizing effect.  Or in other words, you
 14397      can turn off tab-bars by specifying tab-bar-lines zero.  */
 14398   if (!WINDOWP (f->tab_bar_window)
 14399       || (w = XWINDOW (f->tab_bar_window),
 14400           WINDOW_TOTAL_LINES (w) == 0))
 14401     {
 14402       /* Even if we do not display a tab bar initially, still pretend
 14403          that we have resized it.  This avoids that a later activation
 14404          of the tab bar resizes the frame, despite of the fact that the
 14405          setting of 'frame-inhibit-implied-resize' should inhibit it
 14406          (Bug#52986).  */
 14407       f->tab_bar_resized = true;
 14408 
 14409       return false;
 14410     }
 14411 
 14412   /* Build a string that represents the contents of the tab-bar.  */
 14413   build_desired_tab_bar_string (f);
 14414 
 14415   int new_nrows;
 14416   int new_height = tab_bar_height (f, &new_nrows, true);
 14417 
 14418   if (f->n_tab_bar_rows == 0)
 14419     {
 14420       f->n_tab_bar_rows = new_nrows;
 14421       if (new_height != WINDOW_PIXEL_HEIGHT (w))
 14422         frame_default_tab_bar_height = new_height;
 14423     }
 14424 
 14425   /* If new_height or new_nrows indicate that we need to enlarge or
 14426      shrink the tab-bar window, we can return right away.  */
 14427   if (new_nrows > f->n_tab_bar_rows
 14428       || (EQ (Vauto_resize_tab_bars, Qgrow_only)
 14429           && !f->minimize_tab_bar_window_p
 14430           && new_height > WINDOW_PIXEL_HEIGHT (w))
 14431       || (! EQ (Vauto_resize_tab_bars, Qgrow_only)
 14432           && new_height < WINDOW_PIXEL_HEIGHT (w)))
 14433     {
 14434       if (FRAME_TERMINAL (f)->change_tab_bar_height_hook)
 14435         FRAME_TERMINAL (f)->change_tab_bar_height_hook (f, new_height);
 14436       if (new_nrows != f->n_tab_bar_rows)
 14437         f->n_tab_bar_rows = new_nrows;
 14438       clear_glyph_matrix (w->desired_matrix);
 14439       f->fonts_changed = true;
 14440       return true;
 14441     }
 14442 
 14443   /* Set up an iterator for the tab-bar window.  */
 14444   init_iterator (&it, w, -1, -1, w->desired_matrix->rows, TAB_BAR_FACE_ID);
 14445   it.first_visible_x = 0;
 14446   it.last_visible_x = WINDOW_PIXEL_WIDTH (w);
 14447   row = it.glyph_row;
 14448   row->reversed_p = false;
 14449   reseat_to_string (&it, NULL, f->desired_tab_bar_string, 0, 0, 0,
 14450                     STRING_MULTIBYTE (f->desired_tab_bar_string));
 14451   /* FIXME: This should be controlled by a user option.  But it
 14452      doesn't make sense to have an R2L tab bar if the menu bar cannot
 14453      be drawn also R2L, and making the menu bar R2L is tricky due
 14454      tabkit-specific code that implements it.  If an R2L tab bar is
 14455      ever supported, display_tab_bar_line should also be augmented to
 14456      call unproduce_glyphs like display_line and display_string
 14457      do.  */
 14458   it.paragraph_embedding = L2R;
 14459 
 14460   /* Display as many lines as needed to display all tab-bar items.  */
 14461 
 14462   if (f->n_tab_bar_rows > 0)
 14463     {
 14464       int border, rows, height, extra;
 14465 
 14466       if (TYPE_RANGED_FIXNUMP (int, Vtab_bar_border))
 14467         border = XFIXNUM (Vtab_bar_border);
 14468       else if (EQ (Vtab_bar_border, Qinternal_border_width))
 14469         border = FRAME_INTERNAL_BORDER_WIDTH (f);
 14470       else if (EQ (Vtab_bar_border, Qborder_width))
 14471         border = f->border_width;
 14472       else
 14473         border = 0;
 14474       if (border < 0)
 14475         border = 0;
 14476 
 14477       rows = f->n_tab_bar_rows;
 14478       height = max (1, (it.last_visible_y - border) / rows);
 14479       extra = it.last_visible_y - border - height * rows;
 14480 
 14481       while (it.current_y < it.last_visible_y)
 14482         {
 14483           int h = 0;
 14484           if (extra > 0 && rows-- > 0)
 14485             {
 14486               h = (extra + rows - 1) / rows;
 14487               extra -= h;
 14488             }
 14489           display_tab_bar_line (&it, height + h);
 14490         }
 14491     }
 14492   else
 14493     {
 14494       while (it.current_y < it.last_visible_y)
 14495         display_tab_bar_line (&it, 0);
 14496     }
 14497 
 14498   /* It doesn't make much sense to try scrolling in the tab-bar
 14499      window, so don't do it.  */
 14500   w->desired_matrix->no_scrolling_p = true;
 14501   w->must_be_updated_p = true;
 14502 
 14503   if (!NILP (Vauto_resize_tab_bars))
 14504     {
 14505       bool change_height_p = false;
 14506 
 14507       /* If we couldn't display everything, change the tab-bar's
 14508          height if there is room for more.  */
 14509       if (IT_STRING_CHARPOS (it) < it.end_charpos)
 14510         change_height_p = true;
 14511 
 14512       /* We subtract 1 because display_tab_bar_line advances the
 14513          glyph_row pointer before returning to its caller.  We want to
 14514          examine the last glyph row produced by
 14515          display_tab_bar_line.  */
 14516       row = it.glyph_row - 1;
 14517 
 14518       /* If there are blank lines at the end, except for a partially
 14519          visible blank line at the end that is smaller than
 14520          FRAME_LINE_HEIGHT, change the tab-bar's height.  */
 14521       if (!MATRIX_ROW_DISPLAYS_TEXT_P (row)
 14522           && row->height >= FRAME_LINE_HEIGHT (f))
 14523         change_height_p = true;
 14524 
 14525       /* If row displays tab-bar items, but is partially visible,
 14526          change the tab-bar's height.  */
 14527       if (MATRIX_ROW_DISPLAYS_TEXT_P (row)
 14528           && MATRIX_ROW_BOTTOM_Y (row) > it.last_visible_y)
 14529         change_height_p = true;
 14530 
 14531       /* Resize windows as needed by changing the `tab-bar-lines'
 14532          frame parameter.  */
 14533       if (change_height_p)
 14534         {
 14535           int nrows;
 14536           int new_height = tab_bar_height (f, &nrows, true);
 14537 
 14538           change_height_p = ((EQ (Vauto_resize_tab_bars, Qgrow_only)
 14539                               && !f->minimize_tab_bar_window_p)
 14540                              ? (new_height > WINDOW_PIXEL_HEIGHT (w))
 14541                              : (new_height != WINDOW_PIXEL_HEIGHT (w)));
 14542           f->minimize_tab_bar_window_p = false;
 14543 
 14544           if (change_height_p)
 14545             {
 14546               if (FRAME_TERMINAL (f)->change_tab_bar_height_hook)
 14547                 FRAME_TERMINAL (f)->change_tab_bar_height_hook (f, new_height);
 14548               frame_default_tab_bar_height = new_height;
 14549               clear_glyph_matrix (w->desired_matrix);
 14550               f->n_tab_bar_rows = nrows;
 14551               f->fonts_changed = true;
 14552 
 14553               return true;
 14554             }
 14555         }
 14556     }
 14557 
 14558   f->minimize_tab_bar_window_p = false;
 14559   return false;
 14560 }
 14561 
 14562 /* Get information about the tab-bar item which is displayed in GLYPH
 14563    on frame F.  Return in *PROP_IDX the index where tab-bar item
 14564    properties start in F->tab_bar_items.  Return in CLOSE_P an
 14565    indication whether the click was on the close-tab icon of the tab.
 14566    Value is false if GLYPH doesn't display a tab-bar item.  */
 14567 
 14568 static bool
 14569 tab_bar_item_info (struct frame *f, struct glyph *glyph,
 14570                    int *prop_idx, bool *close_p)
 14571 {
 14572   Lisp_Object prop;
 14573   ptrdiff_t charpos;
 14574 
 14575   /* This function can be called asynchronously, which means we must
 14576      exclude any possibility that Fget_text_property signals an
 14577      error.  */
 14578   charpos = min (SCHARS (f->current_tab_bar_string), glyph->charpos);
 14579   charpos = max (0, charpos);
 14580 
 14581   /* Get the text property `menu-item' at pos. The value of that
 14582      property is the start index of this item's properties in
 14583      F->tab_bar_items.  */
 14584   prop = Fget_text_property (make_fixnum (charpos),
 14585                              Qmenu_item, f->current_tab_bar_string);
 14586   if (! FIXNUMP (prop))
 14587     return false;
 14588 
 14589   *prop_idx = XFIXNUM (prop);
 14590 
 14591   if (close_p)
 14592     *close_p = !NILP (Fget_text_property (make_fixnum (charpos),
 14593                                           Qclose_tab,
 14594                                           f->current_tab_bar_string));
 14595 
 14596   return true;
 14597 }
 14598 
 14599 
 14600 /* Get information about the tab-bar item at position X/Y on frame F's
 14601    tab bar window.
 14602 
 14603    Set *GLYPH to a pointer to the glyph of the tab-bar item in the
 14604    current matrix of the tab-bar window of F, or NULL if not on a
 14605    tab-bar item.  Return in *PROP_IDX the index of the tab-bar item in
 14606    F->tab_bar_items.
 14607 
 14608    Place the window-relative vpos of Y in *VPOS, and the
 14609    window-relative hpos of X in *HPOS.  If CLOSE_P, set it to whether
 14610    or not the tab bar item represents a button that should close a
 14611    tab.
 14612 
 14613    Value is
 14614 
 14615    -1   if X/Y is not on a tab-bar item
 14616    0    if X/Y is on the same item that was highlighted before.
 14617    1    otherwise.  */
 14618 
 14619 static int
 14620 get_tab_bar_item (struct frame *f, int x, int y, struct glyph **glyph,
 14621                   int *hpos, int *vpos, int *prop_idx, bool *close_p)
 14622 {
 14623   struct window *w = XWINDOW (f->tab_bar_window);
 14624   int area;
 14625 
 14626   /* Find the glyph under X/Y.  */
 14627   *glyph = x_y_to_hpos_vpos (w, x, y, hpos, vpos, 0, 0, &area);
 14628   if (*glyph == NULL)
 14629     return -1;
 14630 
 14631   /* Get the start of this tab-bar item's properties in
 14632      f->tab_bar_items.  */
 14633   if (!tab_bar_item_info (f, *glyph, prop_idx, close_p))
 14634     return -1;
 14635 
 14636   return *prop_idx == f->last_tab_bar_item ? 0 : 1;
 14637 }
 14638 
 14639 /* EXPORT:
 14640 
 14641    Like `get_tab_bar_item'.  However, don't return anything for GLYPH,
 14642    HPOS, or VPOS, and treat X and Y as relative to F itself, as
 14643    opposed to its tab bar window.  */
 14644 
 14645 int
 14646 get_tab_bar_item_kbd (struct frame *f, int x, int y, int *prop_idx,
 14647                       bool *close_p)
 14648 {
 14649   struct window *w;
 14650   int area, vpos, hpos;
 14651   struct glyph *glyph;
 14652 
 14653   w = XWINDOW (f->tab_bar_window);
 14654 
 14655   /* Convert X and Y to window coordinates.  */
 14656   frame_to_window_pixel_xy (w, &x, &y);
 14657 
 14658   /* Find the glyph under X/Y.  */
 14659   glyph = x_y_to_hpos_vpos (w, x, y, &hpos, &vpos, 0,
 14660                             0, &area);
 14661   if (glyph == NULL)
 14662     return -1;
 14663 
 14664   /* Get the start of this tab-bar item's properties in
 14665      f->tab_bar_items.  */
 14666   if (!tab_bar_item_info (f, glyph, prop_idx, close_p))
 14667     return -1;
 14668 
 14669   return *prop_idx == f->last_tab_bar_item ? 0 : 1;
 14670 }
 14671 
 14672 /* EXPORT:
 14673    Handle mouse button event on the tab-bar of frame F, at
 14674    frame-relative coordinates X/Y.  DOWN_P is true for a button press,
 14675    false for button release.  MODIFIERS is event modifiers for button
 14676    release.  */
 14677 
 14678 Lisp_Object
 14679 handle_tab_bar_click (struct frame *f, int x, int y, bool down_p,
 14680                       int modifiers)
 14681 {
 14682   Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (f);
 14683   struct window *w = XWINDOW (f->tab_bar_window);
 14684   int hpos, vpos, prop_idx;
 14685   bool close_p;
 14686   struct glyph *glyph;
 14687   Lisp_Object enabled_p;
 14688   int ts;
 14689 
 14690   frame_to_window_pixel_xy (w, &x, &y);
 14691   ts = get_tab_bar_item (f, x, y, &glyph, &hpos, &vpos, &prop_idx, &close_p);
 14692   if (ts == -1)
 14693     return Fcons (Qtab_bar, Qnil);
 14694 
 14695   /* If item is disabled, do nothing.  */
 14696   enabled_p = AREF (f->tab_bar_items, prop_idx + TAB_BAR_ITEM_ENABLED_P);
 14697   if (NILP (enabled_p))
 14698     return Qnil;
 14699 
 14700   if (down_p)
 14701     {
 14702       /* Show the clicked button in pressed state.  */
 14703       if (!NILP (Vmouse_highlight))
 14704         show_mouse_face (hlinfo, DRAW_IMAGE_SUNKEN);
 14705       f->last_tab_bar_item = prop_idx; /* record the pressed tab */
 14706     }
 14707   else
 14708     {
 14709       /* Show item in released state.  */
 14710       if (!NILP (Vmouse_highlight))
 14711         show_mouse_face (hlinfo, DRAW_IMAGE_RAISED);
 14712       f->last_tab_bar_item = -1;
 14713     }
 14714 
 14715   Lisp_Object caption =
 14716     Fcopy_sequence (AREF (f->tab_bar_items, prop_idx + TAB_BAR_ITEM_CAPTION));
 14717 
 14718   AUTO_LIST2 (props, Qmenu_item,
 14719               list3 (AREF (f->tab_bar_items, prop_idx + TAB_BAR_ITEM_KEY),
 14720                      AREF (f->tab_bar_items, prop_idx + TAB_BAR_ITEM_BINDING),
 14721                      close_p ? Qt : Qnil));
 14722 
 14723   Fadd_text_properties (make_fixnum (0), make_fixnum (SCHARS (caption)),
 14724                         props, caption);
 14725 
 14726   return Fcons (Qtab_bar, Fcons (caption, make_fixnum (0)));
 14727 }
 14728 
 14729 
 14730 /* Possibly highlight a tab-bar item on frame F when mouse moves to
 14731    tab-bar window-relative coordinates X/Y.  Called from
 14732    note_mouse_highlight.  */
 14733 
 14734 static void
 14735 note_tab_bar_highlight (struct frame *f, int x, int y)
 14736 {
 14737   Lisp_Object window = f->tab_bar_window;
 14738   struct window *w = XWINDOW (window);
 14739   Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (f);
 14740   int hpos, vpos;
 14741   struct glyph *glyph;
 14742   struct glyph_row *row;
 14743   int i;
 14744   Lisp_Object enabled_p;
 14745   int prop_idx;
 14746   bool close_p;
 14747   enum draw_glyphs_face draw = DRAW_IMAGE_RAISED;
 14748   int rc;
 14749 
 14750   /* Function note_mouse_highlight is called with negative X/Y
 14751      values when mouse moves outside of the frame.  */
 14752   if (x <= 0 || y <= 0)
 14753     {
 14754       clear_mouse_face (hlinfo);
 14755       return;
 14756     }
 14757 
 14758   rc = get_tab_bar_item (f, x, y, &glyph, &hpos, &vpos, &prop_idx, &close_p);
 14759   if (rc < 0)
 14760     {
 14761       /* Not on tab-bar item.  */
 14762       clear_mouse_face (hlinfo);
 14763       return;
 14764     }
 14765   else if (rc == 0)
 14766     /* On same tab-bar item as before.  */
 14767     goto set_help_echo;
 14768 
 14769   clear_mouse_face (hlinfo);
 14770 
 14771   bool mouse_down_p = false;
 14772   /* Mouse is down, but on different tab-bar item?  Or alternatively,
 14773      the mouse might've been pressed somewhere we don't know about,
 14774      and then have moved onto the tab bar.  In this case,
 14775      last_tab_bar_item is -1, so we DTRT and behave like other
 14776      programs by displaying the item as sunken. */
 14777   Display_Info *dpyinfo = FRAME_DISPLAY_INFO (f);
 14778   mouse_down_p = (gui_mouse_grabbed (dpyinfo)
 14779                   && f == dpyinfo->last_mouse_frame);
 14780 
 14781   if (mouse_down_p && f->last_tab_bar_item != prop_idx
 14782       && f->last_tab_bar_item != -1)
 14783     return;
 14784   draw = mouse_down_p ? DRAW_IMAGE_SUNKEN : DRAW_IMAGE_RAISED;
 14785 
 14786   /* If tab-bar item is not enabled, don't highlight it.  */
 14787   enabled_p = AREF (f->tab_bar_items, prop_idx + TAB_BAR_ITEM_ENABLED_P);
 14788   if (!NILP (enabled_p) && !NILP (Vmouse_highlight))
 14789     {
 14790       /* Compute the x-position of the glyph.  In front and past the
 14791          image is a space.  We include this in the highlighted area.  */
 14792       row = MATRIX_ROW (w->current_matrix, vpos);
 14793       for (i = x = 0; i < hpos; ++i)
 14794         x += row->glyphs[TEXT_AREA][i].pixel_width;
 14795 
 14796       /* Record this as the current active region.  */
 14797       hlinfo->mouse_face_beg_col = hpos;
 14798       hlinfo->mouse_face_beg_row = vpos;
 14799       hlinfo->mouse_face_beg_x = x;
 14800       hlinfo->mouse_face_past_end = false;
 14801 
 14802       hlinfo->mouse_face_end_col = hpos + 1;
 14803       hlinfo->mouse_face_end_row = vpos;
 14804       hlinfo->mouse_face_end_x = x + glyph->pixel_width;
 14805       hlinfo->mouse_face_window = window;
 14806       hlinfo->mouse_face_face_id = TAB_BAR_FACE_ID;
 14807 
 14808       /* Display it as active.  */
 14809       show_mouse_face (hlinfo, draw);
 14810     }
 14811 
 14812  set_help_echo:
 14813 
 14814   /* Set help_echo_string to a help string to display for this tab-bar item.
 14815      XTread_socket does the rest.  */
 14816   help_echo_object = help_echo_window = Qnil;
 14817   help_echo_pos = -1;
 14818   help_echo_string = AREF (f->tab_bar_items, prop_idx + TAB_BAR_ITEM_HELP);
 14819   if (NILP (help_echo_string))
 14820     help_echo_string = AREF (f->tab_bar_items, prop_idx + TAB_BAR_ITEM_CAPTION);
 14821 }
 14822 
 14823 #endif /* HAVE_WINDOW_SYSTEM */
 14824 
 14825 /* Find the tab-bar item at X coordinate and return its information.  */
 14826 static Lisp_Object
 14827 tty_get_tab_bar_item (struct frame *f, int x, int *prop_idx, bool *close_p)
 14828 {
 14829   ptrdiff_t clen = 0;
 14830 
 14831   for (int i = 0; i < f->n_tab_bar_items; i++)
 14832     {
 14833       Lisp_Object caption = AREF (f->tab_bar_items, (i * TAB_BAR_ITEM_NSLOTS
 14834                                                      + TAB_BAR_ITEM_CAPTION));
 14835       if (NILP (caption))
 14836         return Qnil;
 14837       clen += SCHARS (caption);
 14838       if (x < clen)
 14839         {
 14840           *prop_idx = i;
 14841           *close_p = !NILP (Fget_text_property (make_fixnum (SCHARS (caption)
 14842                                                              - (clen - x)),
 14843                                                 Qclose_tab,
 14844                                                 caption));
 14845           return caption;
 14846         }
 14847     }
 14848   return Qnil;
 14849 }
 14850 
 14851 /* Handle a mouse click at X/Y on the tab bar of TTY frame F.  If the
 14852    click was on the tab bar and was handled, populate the EVENT
 14853    structure, store it in keyboard queue, and return true; otherwise
 14854    return false.  MODIFIERS are event modifiers for generating the tab
 14855    release event.  */
 14856 Lisp_Object
 14857 tty_handle_tab_bar_click (struct frame *f, int x, int y, bool down_p,
 14858                           struct input_event *event)
 14859 {
 14860   /* Did they click on the tab bar?  */
 14861   if (y < FRAME_MENU_BAR_LINES (f)
 14862       || y >= FRAME_MENU_BAR_LINES (f) + FRAME_TAB_BAR_LINES (f))
 14863     return Qnil;
 14864 
 14865   /* Find the tab-bar item where the X,Y coordinates belong.  */
 14866   int prop_idx;
 14867   bool close_p;
 14868   Lisp_Object caption = tty_get_tab_bar_item (f, x, &prop_idx, &close_p);
 14869 
 14870   if (NILP (caption))
 14871     return Qnil;
 14872 
 14873   if (NILP (AREF (f->tab_bar_items,
 14874                   prop_idx * TAB_BAR_ITEM_NSLOTS + TAB_BAR_ITEM_ENABLED_P)))
 14875     return Qnil;
 14876 
 14877   if (down_p)
 14878     f->last_tab_bar_item = prop_idx;
 14879   else
 14880     f->last_tab_bar_item = -1;
 14881 
 14882   caption = Fcopy_sequence (caption);
 14883 
 14884   AUTO_LIST2 (props, Qmenu_item,
 14885               list3 (AREF (f->tab_bar_items, prop_idx * TAB_BAR_ITEM_NSLOTS
 14886                            + TAB_BAR_ITEM_KEY),
 14887                      AREF (f->tab_bar_items, prop_idx * TAB_BAR_ITEM_NSLOTS
 14888                            + TAB_BAR_ITEM_BINDING),
 14889                      close_p ? Qt : Qnil));
 14890 
 14891   Fadd_text_properties (make_fixnum (0), make_fixnum (SCHARS (caption)),
 14892                         props, caption);
 14893 
 14894   return Fcons (Qtab_bar, Fcons (caption, make_fixnum (0)));
 14895 }
 14896 
 14897 
 14898 
 14899 /***********************************************************************
 14900                                Tool-bars
 14901  ***********************************************************************/
 14902 
 14903 #ifdef HAVE_WINDOW_SYSTEM
 14904 
 14905 /* Update the tool-bar item list for frame F.  This has to be done
 14906    before we start to fill in any display lines.  Called from
 14907    prepare_menu_bars.  If SAVE_MATCH_DATA, we must save
 14908    and restore it here.  */
 14909 
 14910 static void
 14911 update_tool_bar (struct frame *f, bool save_match_data)
 14912 {
 14913 #ifdef HAVE_EXT_TOOL_BAR
 14914   bool do_update = FRAME_EXTERNAL_TOOL_BAR (f);
 14915 #else
 14916   bool do_update = (WINDOWP (f->tool_bar_window)
 14917                     && WINDOW_TOTAL_LINES (XWINDOW (f->tool_bar_window)) > 0);
 14918 #endif
 14919 
 14920   if (do_update)
 14921     {
 14922       Lisp_Object window;
 14923       struct window *w;
 14924 
 14925       window = FRAME_SELECTED_WINDOW (f);
 14926       w = XWINDOW (window);
 14927 
 14928       /* If the user has switched buffers or windows, we need to
 14929          recompute to reflect the new bindings.  But we'll
 14930          recompute when update_mode_lines is set too; that means
 14931          that people can use force-mode-line-update to request
 14932          that the menu bar be recomputed.  The adverse effect on
 14933          the rest of the redisplay algorithm is about the same as
 14934          windows_or_buffers_changed anyway.  */
 14935       if (windows_or_buffers_changed
 14936           || w->update_mode_line
 14937           || update_mode_lines
 14938           || window_buffer_changed (w))
 14939         {
 14940           struct buffer *prev = current_buffer;
 14941           specpdl_ref count = SPECPDL_INDEX ();
 14942           Lisp_Object frame, new_tool_bar;
 14943           int new_n_tool_bar;
 14944 
 14945           /* Set current_buffer to the buffer of the selected
 14946              window of the frame, so that we get the right local
 14947              keymaps.  */
 14948           set_buffer_internal_1 (XBUFFER (w->contents));
 14949 
 14950           /* Save match data, if we must.  */
 14951           if (save_match_data)
 14952             record_unwind_save_match_data ();
 14953 
 14954           /* Make sure that we don't accidentally use bogus keymaps.  */
 14955           if (NILP (Voverriding_local_map_menu_flag))
 14956             {
 14957               specbind (Qoverriding_terminal_local_map, Qnil);
 14958               specbind (Qoverriding_local_map, Qnil);
 14959             }
 14960 
 14961           /* We must temporarily set the selected frame to this frame
 14962              before calling tool_bar_items, because the calculation of
 14963              the tool-bar keymap uses the selected frame (see
 14964              `tool-bar-make-keymap' in tool-bar.el).  */
 14965           eassert (EQ (selected_window,
 14966                        /* Since we only explicitly preserve selected_frame,
 14967                           check that selected_window would be redundant.  */
 14968                        XFRAME (selected_frame)->selected_window));
 14969           record_unwind_protect (restore_selected_window, selected_window);
 14970           XSETFRAME (frame, f);
 14971           selected_frame = frame;
 14972           selected_window = FRAME_SELECTED_WINDOW (f);
 14973 
 14974           /* Build desired tool-bar items from keymaps.  */
 14975           new_tool_bar
 14976             = tool_bar_items (Fcopy_sequence (f->tool_bar_items),
 14977                               &new_n_tool_bar);
 14978 
 14979           /* Redisplay the tool-bar if we changed it.  */
 14980           if (new_n_tool_bar != f->n_tool_bar_items
 14981               || NILP (Fequal (new_tool_bar, f->tool_bar_items)))
 14982             {
 14983               /* Redisplay that happens asynchronously due to an expose event
 14984                  may access f->tool_bar_items.  Make sure we update both
 14985                  variables within BLOCK_INPUT so no such event interrupts.  */
 14986               block_input ();
 14987               fset_tool_bar_items (f, new_tool_bar);
 14988               f->n_tool_bar_items = new_n_tool_bar;
 14989               w->update_mode_line = true;
 14990               unblock_input ();
 14991             }
 14992 
 14993           unbind_to (count, Qnil);
 14994           set_buffer_internal_1 (prev);
 14995         }
 14996     }
 14997 }
 14998 
 14999 #ifndef HAVE_EXT_TOOL_BAR
 15000 
 15001 /* Set F->desired_tool_bar_string to a Lisp string representing frame
 15002    F's desired tool-bar contents.  F->tool_bar_items must have
 15003    been set up previously by calling prepare_menu_bars.
 15004 
 15005    Also set F->tool_bar_wraps_p to whether or not the tool bar
 15006    contains explicit line breaking items.  */
 15007 
 15008 static void
 15009 build_desired_tool_bar_string (struct frame *f)
 15010 {
 15011   int i, size, size_needed;
 15012   Lisp_Object image, plist;
 15013 
 15014   image = plist = Qnil;
 15015 
 15016   /* Prepare F->desired_tool_bar_string.  If we can reuse it, do so.
 15017      Otherwise, make a new string.  */
 15018 
 15019   /* The size of the string we might be able to reuse.  */
 15020   size = (STRINGP (f->desired_tool_bar_string)
 15021           ? SCHARS (f->desired_tool_bar_string)
 15022           : 0);
 15023 
 15024   /* We need one space in the string for each image.  */
 15025   size_needed = f->n_tool_bar_items;
 15026 
 15027   /* Reuse f->desired_tool_bar_string, if possible.  */
 15028 
 15029   if (size < size_needed || NILP (f->desired_tool_bar_string))
 15030     /* Don't initialize the contents of this string yet, as they will
 15031        be set within the loop below.  */
 15032     fset_desired_tool_bar_string (f, make_uninit_string (size_needed));
 15033   else
 15034     {
 15035       AUTO_LIST4 (props, Qdisplay, Qnil, Qmenu_item, Qnil);
 15036       Fremove_text_properties (make_fixnum (0), make_fixnum (size),
 15037                                props, f->desired_tool_bar_string);
 15038     }
 15039 
 15040   f->tool_bar_wraps_p = false;
 15041 
 15042   /* Put a `display' property on the string for the images to display,
 15043      put a `menu_item' property on tool-bar items with a value that
 15044      is the index of the item in F's tool-bar item vector.  */
 15045   for (i = 0; i < f->n_tool_bar_items; ++i)
 15046     {
 15047 #define PROP(IDX) \
 15048   AREF (f->tool_bar_items, i * TOOL_BAR_ITEM_NSLOTS + (IDX))
 15049 
 15050       bool enabled_p = !NILP (PROP (TOOL_BAR_ITEM_ENABLED_P));
 15051       bool selected_p = !NILP (PROP (TOOL_BAR_ITEM_SELECTED_P));
 15052       int hmargin, vmargin, relief, idx, end;
 15053 
 15054       if (!NILP (PROP (TOOL_BAR_ITEM_WRAP)))
 15055         {
 15056           /* This is a line wrap.  Instead of building a tool bar
 15057              item, display a new line character instead.  */
 15058           SSET (f->desired_tool_bar_string, i, '\n');
 15059 
 15060           /* Set F->tool_bar_wraps_p.  This tells redisplay_tool_bar
 15061              to allow individual rows to be different heights.  */
 15062           f->tool_bar_wraps_p = true;
 15063           continue;
 15064         }
 15065 
 15066       /* Replace this with a space character.  */
 15067       SSET (f->desired_tool_bar_string, i, ' ');
 15068 
 15069       /* If image is a vector, choose the image according to the
 15070          button state.  */
 15071       image = PROP (TOOL_BAR_ITEM_IMAGES);
 15072       if (VECTORP (image))
 15073         {
 15074           if (enabled_p)
 15075             idx = (selected_p
 15076                    ? TOOL_BAR_IMAGE_ENABLED_SELECTED
 15077                    : TOOL_BAR_IMAGE_ENABLED_DESELECTED);
 15078           else
 15079             idx = (selected_p
 15080                    ? TOOL_BAR_IMAGE_DISABLED_SELECTED
 15081                    : TOOL_BAR_IMAGE_DISABLED_DESELECTED);
 15082 
 15083           eassert (ASIZE (image) >= idx);
 15084           image = AREF (image, idx);
 15085         }
 15086       else
 15087         idx = -1;
 15088 
 15089       /* Ignore invalid image specifications.  */
 15090       if (!valid_image_p (image))
 15091         continue;
 15092 
 15093       /* Display the tool-bar button pressed, or depressed.  */
 15094       plist = Fcopy_sequence (XCDR (image));
 15095 
 15096       /* Compute margin and relief to draw.  */
 15097       relief = (tool_bar_button_relief >= 0
 15098                 ? min (tool_bar_button_relief,
 15099                        min (INT_MAX, MOST_POSITIVE_FIXNUM))
 15100                 : DEFAULT_TOOL_BAR_BUTTON_RELIEF);
 15101       hmargin = vmargin = relief;
 15102 
 15103       if (RANGED_FIXNUMP (1, Vtool_bar_button_margin,
 15104                            INT_MAX - max (hmargin, vmargin)))
 15105         {
 15106           hmargin += XFIXNAT (Vtool_bar_button_margin);
 15107           vmargin += XFIXNAT (Vtool_bar_button_margin);
 15108         }
 15109       else if (CONSP (Vtool_bar_button_margin))
 15110         {
 15111           if (RANGED_FIXNUMP (1, XCAR (Vtool_bar_button_margin),
 15112                                INT_MAX - hmargin))
 15113             hmargin += XFIXNAT (XCAR (Vtool_bar_button_margin));
 15114 
 15115           if (RANGED_FIXNUMP (1, XCDR (Vtool_bar_button_margin),
 15116                                INT_MAX - vmargin))
 15117             vmargin += XFIXNAT (XCDR (Vtool_bar_button_margin));
 15118         }
 15119 
 15120       if (auto_raise_tool_bar_buttons_p)
 15121         {
 15122           /* Add a `:relief' property to the image spec if the item is
 15123              selected.  */
 15124           if (selected_p)
 15125             {
 15126               plist = plist_put (plist, QCrelief, make_fixnum (-relief));
 15127               hmargin -= relief;
 15128               vmargin -= relief;
 15129             }
 15130         }
 15131       else
 15132         {
 15133           /* If image is selected, display it pressed, i.e. with a
 15134              negative relief.  If it's not selected, display it with a
 15135              raised relief.  */
 15136           plist = plist_put (plist, QCrelief,
 15137                              (selected_p
 15138                               ? make_fixnum (-relief)
 15139                               : make_fixnum (relief)));
 15140           hmargin -= relief;
 15141           vmargin -= relief;
 15142         }
 15143 
 15144       /* Put a margin around the image.  */
 15145       if (hmargin || vmargin)
 15146         {
 15147           if (hmargin == vmargin)
 15148             plist = plist_put (plist, QCmargin, make_fixnum (hmargin));
 15149           else
 15150             plist = plist_put (plist, QCmargin,
 15151                                Fcons (make_fixnum (hmargin),
 15152                                       make_fixnum (vmargin)));
 15153         }
 15154 
 15155       /* If button is not enabled, and we don't have special images
 15156          for the disabled state, make the image appear disabled by
 15157          applying an appropriate algorithm to it.  */
 15158       if (!enabled_p && idx < 0)
 15159         plist = plist_put (plist, QCconversion, Qdisabled);
 15160 
 15161       /* Put a `display' text property on the string for the image to
 15162          display.  Put a `menu-item' property on the string that gives
 15163          the start of this item's properties in the tool-bar items
 15164          vector.  */
 15165       image = Fcons (Qimage, plist);
 15166       AUTO_LIST4 (props, Qdisplay, image, Qmenu_item,
 15167                   make_fixnum (i * TOOL_BAR_ITEM_NSLOTS));
 15168 
 15169       /* Let the last image hide all remaining spaces in the tool bar
 15170          string.  The string can be longer than needed when we reuse a
 15171          previous string.  */
 15172       if (i + 1 == f->n_tool_bar_items)
 15173         end = SCHARS (f->desired_tool_bar_string);
 15174       else
 15175         end = i + 1;
 15176       Fadd_text_properties (make_fixnum (i), make_fixnum (end),
 15177                             props, f->desired_tool_bar_string);
 15178 #undef PROP
 15179     }
 15180 
 15181   /* Now replace each character between i and the end of the tool bar
 15182      string with spaces, to prevent stray newlines from accumulating
 15183      when the number of tool bar items decreases.  `size' is 0 if the
 15184      tool bar string is new, but in that case the string will have
 15185      been completely initialized anyway.  */
 15186 
 15187   for (; i < size; ++i)
 15188     /* Replace this with a space character.  */
 15189     SSET (f->desired_tool_bar_string, i, ' ');
 15190 }
 15191 
 15192 
 15193 /* Display one line of the tool-bar of frame IT->f.
 15194 
 15195    HEIGHT specifies the desired height of the tool-bar line.
 15196    If the actual height of the glyph row is less than HEIGHT, the
 15197    row's height is increased to HEIGHT, and the icons are centered
 15198    vertically in the new height.
 15199 
 15200    If HEIGHT is -1, we are counting needed tool-bar lines, so don't
 15201    count a final empty row in case the tool-bar width exactly matches
 15202    the window width.
 15203 
 15204    HEIGHT may also be -1 if there is an explicit line wrapping item
 15205    inside the tool bar; in that case, allow individual rows of the
 15206    tool bar to differ in height.  */
 15207 
 15208 static void
 15209 display_tool_bar_line (struct it *it, int height)
 15210 {
 15211   struct glyph_row *row = it->glyph_row;
 15212   int max_x = it->last_visible_x;
 15213   struct glyph *last;
 15214 
 15215   /* Don't extend on a previously drawn tool bar items (Bug#16058).  */
 15216   clear_glyph_row (row);
 15217   row->enabled_p = true;
 15218   row->y = it->current_y;
 15219 
 15220   /* Note that this isn't made use of if the face hasn't a box,
 15221      so there's no need to check the face here.  */
 15222   it->start_of_box_run_p = true;
 15223 
 15224   while (it->current_x < max_x)
 15225     {
 15226       int x, n_glyphs_before, i, nglyphs;
 15227       struct it it_before;
 15228 
 15229       /* Get the next display element.  */
 15230       if (!get_next_display_element (it))
 15231         {
 15232           /* Don't count empty row if we are counting needed tool-bar lines.  */
 15233           if (height < 0 && !it->hpos)
 15234             return;
 15235           break;
 15236         }
 15237 
 15238       /* Produce glyphs.  */
 15239       n_glyphs_before = row->used[TEXT_AREA];
 15240       it_before = *it;
 15241 
 15242       PRODUCE_GLYPHS (it);
 15243 
 15244       nglyphs = row->used[TEXT_AREA] - n_glyphs_before;
 15245       i = 0;
 15246       x = it_before.current_x;
 15247       while (i < nglyphs)
 15248         {
 15249           struct glyph *glyph = row->glyphs[TEXT_AREA] + n_glyphs_before + i;
 15250 
 15251           if (x + glyph->pixel_width > max_x)
 15252             {
 15253               /* Glyph doesn't fit on line.  Backtrack.  */
 15254               row->used[TEXT_AREA] = n_glyphs_before;
 15255               *it = it_before;
 15256               /* If this is the only glyph on this line, it will never fit on the
 15257                  tool-bar, so skip it.  But ensure there is at least one glyph,
 15258                  so we don't accidentally disable the tool-bar.  */
 15259               if (n_glyphs_before == 0
 15260                   && (it->vpos > 0 || IT_STRING_CHARPOS (*it) < it->end_charpos-1))
 15261                 break;
 15262               goto out;
 15263             }
 15264 
 15265           ++it->hpos;
 15266           x += glyph->pixel_width;
 15267           ++i;
 15268         }
 15269 
 15270       /* Stop at the end of the iterator, and move to the next line
 15271          upon a '\n' appearing in the tool bar string.  Tool bar
 15272          strings may contain multiple new line characters when
 15273          explicit wrap items are encountered.  */
 15274 
 15275       if (ITERATOR_AT_END_OF_LINE_P (it))
 15276         {
 15277           reseat_at_next_visible_line_start (it, false);
 15278           break;
 15279         }
 15280 
 15281       if (ITERATOR_AT_END_P (it))
 15282         break;
 15283 
 15284       set_iterator_to_next (it, true);
 15285     }
 15286 
 15287  out:;
 15288 
 15289   row->displays_text_p = row->used[TEXT_AREA] != 0;
 15290 
 15291   /* Use default face for the border below the tool bar.
 15292 
 15293      FIXME: When auto-resize-tool-bars is grow-only, there is
 15294      no additional border below the possibly empty tool-bar lines.
 15295      So to make the extra empty lines look "normal", we have to
 15296      use the tool-bar face for the border too.  */
 15297   if (!MATRIX_ROW_DISPLAYS_TEXT_P (row)
 15298       && !EQ (Vauto_resize_tool_bars, Qgrow_only))
 15299     it->face_id = DEFAULT_FACE_ID;
 15300 
 15301   extend_face_to_end_of_line (it);
 15302   last = row->glyphs[TEXT_AREA] + row->used[TEXT_AREA] - 1;
 15303   last->right_box_line_p = true;
 15304   if (last == row->glyphs[TEXT_AREA])
 15305     last->left_box_line_p = true;
 15306 
 15307   /* Make line the desired height and center it vertically.  */
 15308   if (height != -1
 15309       && (height -= it->max_ascent + it->max_descent) > 0)
 15310     {
 15311       /* Don't add more than one line height.  */
 15312       height %= FRAME_LINE_HEIGHT (it->f);
 15313       it->max_ascent += height / 2;
 15314       it->max_descent += (height + 1) / 2;
 15315     }
 15316 
 15317   compute_line_metrics (it);
 15318 
 15319   /* If line is empty, make it occupy the rest of the tool-bar.  */
 15320   if (!MATRIX_ROW_DISPLAYS_TEXT_P (row))
 15321     {
 15322       row->height = row->phys_height = it->last_visible_y - row->y;
 15323       row->visible_height = row->height;
 15324       row->ascent = row->phys_ascent = 0;
 15325       row->extra_line_spacing = 0;
 15326     }
 15327 
 15328   row->full_width_p = true;
 15329   row->continued_p = false;
 15330   row->truncated_on_left_p = false;
 15331   row->truncated_on_right_p = false;
 15332 
 15333   it->current_x = it->hpos = 0;
 15334   it->current_y += row->height;
 15335   ++it->vpos;
 15336   ++it->glyph_row;
 15337 }
 15338 
 15339 
 15340 /* Value is the number of pixels needed to make all tool-bar items of
 15341    frame F visible.  The actual number of glyph rows needed is
 15342    returned in *N_ROWS if non-NULL.  */
 15343 
 15344 static int
 15345 tool_bar_height (struct frame *f, int *n_rows, bool pixelwise)
 15346 {
 15347   struct window *w = XWINDOW (f->tool_bar_window);
 15348   struct it it;
 15349   /* tool_bar_height is called from redisplay_tool_bar after building
 15350      the desired matrix, so use (unused) mode-line row as temporary row to
 15351      avoid destroying the first tool-bar row.  */
 15352   struct glyph_row *temp_row = MATRIX_MODE_LINE_ROW (w->desired_matrix);
 15353 
 15354   /* Initialize an iterator for iteration over
 15355      F->desired_tool_bar_string in the tool-bar window of frame F.  */
 15356   init_iterator (&it, w, -1, -1, temp_row, TOOL_BAR_FACE_ID);
 15357   temp_row->reversed_p = false;
 15358   it.first_visible_x = 0;
 15359   it.last_visible_x = WINDOW_PIXEL_WIDTH (w);
 15360   reseat_to_string (&it, NULL, f->desired_tool_bar_string,
 15361                     0, 0, 0, STRING_MULTIBYTE (f->desired_tool_bar_string));
 15362   it.paragraph_embedding = L2R;
 15363 
 15364   while (!ITERATOR_AT_END_P (&it))
 15365     {
 15366       clear_glyph_row (temp_row);
 15367       it.glyph_row = temp_row;
 15368       display_tool_bar_line (&it, -1);
 15369     }
 15370   clear_glyph_row (temp_row);
 15371 
 15372   /* f->n_tool_bar_rows == 0 means "unknown"; -1 means no tool-bar.  */
 15373   if (n_rows)
 15374     *n_rows = it.vpos > 0 ? it.vpos : -1;
 15375 
 15376   if (pixelwise)
 15377     return it.current_y;
 15378   else
 15379     return (it.current_y + FRAME_LINE_HEIGHT (f) - 1) / FRAME_LINE_HEIGHT (f);
 15380 }
 15381 
 15382 #endif /* ! (HAVE_EXT_TOOL_BAR) */
 15383 
 15384 DEFUN ("tool-bar-height", Ftool_bar_height, Stool_bar_height,
 15385        0, 2, 0,
 15386        doc: /* Return the number of lines occupied by the tool bar of FRAME.
 15387 If FRAME is nil or omitted, use the selected frame.  Optional argument
 15388 PIXELWISE non-nil means return the height of the tool bar in pixels.  */)
 15389   (Lisp_Object frame, Lisp_Object pixelwise)
 15390 {
 15391   int height = 0;
 15392 
 15393 #ifndef HAVE_EXT_TOOL_BAR
 15394   struct frame *f = decode_any_frame (frame);
 15395 
 15396   if (WINDOWP (f->tool_bar_window)
 15397       && WINDOW_PIXEL_HEIGHT (XWINDOW (f->tool_bar_window)) > 0)
 15398     {
 15399       update_tool_bar (f, true);
 15400       if (f->n_tool_bar_items)
 15401         {
 15402           build_desired_tool_bar_string (f);
 15403           height = tool_bar_height (f, NULL, !NILP (pixelwise));
 15404         }
 15405     }
 15406 #endif
 15407 
 15408   return make_fixnum (height);
 15409 }
 15410 
 15411 #ifndef HAVE_EXT_TOOL_BAR
 15412 
 15413 /* Display the internal tool-bar of frame F.  Value is true if
 15414    tool-bar's height should be changed.  */
 15415 static bool
 15416 redisplay_tool_bar (struct frame *f)
 15417 {
 15418   struct window *w;
 15419   struct it it;
 15420   struct glyph_row *row;
 15421   bool change_height_p;
 15422 
 15423   change_height_p = false;
 15424   f->tool_bar_redisplayed = true;
 15425 
 15426   /* If frame hasn't a tool-bar window or if it is zero-height, don't
 15427      do anything.  This means you must start with tool-bar-lines
 15428      non-zero to get the auto-sizing effect.  Or in other words, you
 15429      can turn off tool-bars by specifying tool-bar-lines zero.  */
 15430   if (!WINDOWP (f->tool_bar_window)
 15431       || (w = XWINDOW (f->tool_bar_window),
 15432           WINDOW_TOTAL_LINES (w) == 0))
 15433     {
 15434       /* Even if we do not display a tool bar initially, still pretend
 15435          that we have resized it already.  This avoids that a later
 15436          activation of the tool bar resizes the frame, despite of the
 15437          fact that a setting of 'frame-inhibit-implied-resize' should
 15438          inhibit it (Bug#52986).  */
 15439       f->tool_bar_resized = true;
 15440 
 15441       return false;
 15442     }
 15443 
 15444   /* Set up an iterator for the tool-bar window.  */
 15445   init_iterator (&it, w, -1, -1, w->desired_matrix->rows, TOOL_BAR_FACE_ID);
 15446   it.first_visible_x = 0;
 15447   it.last_visible_x = WINDOW_PIXEL_WIDTH (w);
 15448   row = it.glyph_row;
 15449   row->reversed_p = false;
 15450 
 15451   /* Build a string that represents the contents of the tool-bar.  */
 15452   build_desired_tool_bar_string (f);
 15453   reseat_to_string (&it, NULL, f->desired_tool_bar_string,
 15454                     0, 0, 0, STRING_MULTIBYTE (f->desired_tool_bar_string));
 15455   /* FIXME: This should be controlled by a user option.  But it
 15456      doesn't make sense to have an R2L tool bar if the menu bar cannot
 15457      be drawn also R2L, and making the menu bar R2L is tricky due to
 15458      toolkit-specific code that implements it.  If an R2L tool bar is
 15459      ever supported, display_tool_bar_line should also be augmented to
 15460      call unproduce_glyphs like display_line and display_string
 15461      do.  */
 15462   it.paragraph_embedding = L2R;
 15463 
 15464   if (f->n_tool_bar_rows == 0)
 15465     {
 15466       int new_height = tool_bar_height (f, &f->n_tool_bar_rows, true);
 15467 
 15468       if (new_height != WINDOW_PIXEL_HEIGHT (w))
 15469         {
 15470           if (FRAME_TERMINAL (f)->change_tool_bar_height_hook)
 15471             FRAME_TERMINAL (f)->change_tool_bar_height_hook (f, new_height);
 15472           frame_default_tool_bar_height = new_height;
 15473           /* Always do that now.  */
 15474           clear_glyph_matrix (w->desired_matrix);
 15475           f->fonts_changed = true;
 15476 
 15477           /* Kludge (this applies to the X Windows version as well as
 15478              Android): when the tool bar size changes,
 15479              adjust_window_size (presumably called by
 15480              change_tool_bar_height_hook) does not call through to
 15481              resize_frame_windows.  Pending further investigation,
 15482              just call it here as well.  */
 15483           resize_frame_windows (f, FRAME_INNER_HEIGHT (f), false);
 15484 
 15485           return true;
 15486         }
 15487     }
 15488 
 15489   /* Display as many lines as needed to display all tool-bar items.  */
 15490 
 15491   if (f->n_tool_bar_rows > 0)
 15492     {
 15493       int border, rows, height, extra;
 15494 
 15495       if (TYPE_RANGED_FIXNUMP (int, Vtool_bar_border))
 15496         border = XFIXNUM (Vtool_bar_border);
 15497       else if (EQ (Vtool_bar_border, Qinternal_border_width))
 15498         border = FRAME_INTERNAL_BORDER_WIDTH (f);
 15499       else if (EQ (Vtool_bar_border, Qborder_width))
 15500         border = f->border_width;
 15501       else
 15502         border = 0;
 15503       if (border < 0)
 15504         border = 0;
 15505 
 15506       rows = f->n_tool_bar_rows;
 15507 
 15508       if (f->tool_bar_wraps_p)
 15509         {
 15510           /* If the tool bar contains explicit line wrapping items,
 15511              don't force each row to have a fixed height.  */
 15512 
 15513           while (!ITERATOR_AT_END_P (&it))
 15514             display_tool_bar_line (&it, -1);
 15515 
 15516           /* Because changes to individual tool bar items may now
 15517              change the height of the tool bar, adjust the height of
 15518              the tool bar window if it is different from the tool bar
 15519              height in any way.  */
 15520 
 15521           if (it.current_y != it.last_visible_y)
 15522             change_height_p = true;
 15523         }
 15524       else
 15525         {
 15526           height = max (1, (it.last_visible_y - border) / rows);
 15527           extra = it.last_visible_y - border - height * rows;
 15528 
 15529           while (it.current_y < it.last_visible_y)
 15530             {
 15531               int h = 0;
 15532               if (extra > 0 && rows-- > 0)
 15533                 {
 15534                   h = (extra + rows - 1) / rows;
 15535                   extra -= h;
 15536                 }
 15537           
 15538               display_tool_bar_line (&it, height + h);
 15539             }
 15540         }
 15541     }
 15542   else
 15543     {
 15544       while (it.current_y < it.last_visible_y)
 15545         display_tool_bar_line (&it, 0);
 15546     }
 15547 
 15548   /* It doesn't make much sense to try scrolling in the tool-bar
 15549      window, so don't do it.  */
 15550   w->desired_matrix->no_scrolling_p = true;
 15551   w->must_be_updated_p = true;
 15552 
 15553   if (!NILP (Vauto_resize_tool_bars))
 15554     {
 15555       /* If we couldn't display everything, change the tool-bar's
 15556          height if there is room for more.  */
 15557       if (IT_STRING_CHARPOS (it) < it.end_charpos)
 15558         change_height_p = true;
 15559 
 15560       /* We subtract 1 because display_tool_bar_line advances the
 15561          glyph_row pointer before returning to its caller.  We want to
 15562          examine the last glyph row produced by
 15563          display_tool_bar_line.  */
 15564       row = it.glyph_row - 1;
 15565 
 15566       /* If there are blank lines at the end, except for a partially
 15567          visible blank line at the end that is smaller than
 15568          FRAME_LINE_HEIGHT, change the tool-bar's height.  */
 15569       if (!MATRIX_ROW_DISPLAYS_TEXT_P (row)
 15570           && row->height >= FRAME_LINE_HEIGHT (f))
 15571         change_height_p = true;
 15572 
 15573       /* If row displays tool-bar items, but is partially visible,
 15574          change the tool-bar's height.  */
 15575       if (MATRIX_ROW_DISPLAYS_TEXT_P (row)
 15576           && MATRIX_ROW_BOTTOM_Y (row) > it.last_visible_y)
 15577         change_height_p = true;
 15578 
 15579       /* Resize windows as needed by changing the `tool-bar-lines'
 15580          frame parameter.  */
 15581       if (change_height_p)
 15582         {
 15583           int nrows;
 15584           int new_height = tool_bar_height (f, &nrows, true);
 15585 
 15586           change_height_p = ((EQ (Vauto_resize_tool_bars, Qgrow_only)
 15587                               && !f->minimize_tool_bar_window_p)
 15588                              ? (new_height > WINDOW_PIXEL_HEIGHT (w))
 15589                              : (new_height != WINDOW_PIXEL_HEIGHT (w)));
 15590           f->minimize_tool_bar_window_p = false;
 15591 
 15592           if (change_height_p)
 15593             {
 15594               if (FRAME_TERMINAL (f)->change_tool_bar_height_hook)
 15595                 FRAME_TERMINAL (f)->change_tool_bar_height_hook (f, new_height);
 15596               frame_default_tool_bar_height = new_height;
 15597               clear_glyph_matrix (w->desired_matrix);
 15598               f->n_tool_bar_rows = nrows;
 15599               f->fonts_changed = true;
 15600 
 15601               return true;
 15602             }
 15603         }
 15604     }
 15605 
 15606   f->minimize_tool_bar_window_p = false;
 15607 
 15608   return false;
 15609 }
 15610 
 15611 /* Get information about the tool-bar item which is displayed in GLYPH
 15612    on frame F.  Return in *PROP_IDX the index where tool-bar item
 15613    properties start in F->tool_bar_items.  Value is false if
 15614    GLYPH doesn't display a tool-bar item.  */
 15615 
 15616 static bool
 15617 tool_bar_item_info (struct frame *f, struct glyph *glyph, int *prop_idx)
 15618 {
 15619   Lisp_Object prop;
 15620   ptrdiff_t charpos;
 15621 
 15622   /* This function can be called asynchronously, which means we must
 15623      exclude any possibility that Fget_text_property signals an
 15624      error.  */
 15625   charpos = min (SCHARS (f->current_tool_bar_string), glyph->charpos);
 15626   charpos = max (0, charpos);
 15627 
 15628   /* Get the text property `menu-item' at pos. The value of that
 15629      property is the start index of this item's properties in
 15630      F->tool_bar_items.  */
 15631   prop = Fget_text_property (make_fixnum (charpos),
 15632                              Qmenu_item, f->current_tool_bar_string);
 15633   if (! FIXNUMP (prop))
 15634     return false;
 15635   *prop_idx = XFIXNUM (prop);
 15636   return true;
 15637 }
 15638 
 15639 
 15640 /* Get information about the tool-bar item at position X/Y on frame F.
 15641    Return in *GLYPH a pointer to the glyph of the tool-bar item in
 15642    the current matrix of the tool-bar window of F, or NULL if not
 15643    on a tool-bar item.  Return in *PROP_IDX the index of the tool-bar
 15644    item in F->tool_bar_items.  Value is
 15645 
 15646    -1   if X/Y is not on a tool-bar item
 15647    0    if X/Y is on the same item that was highlighted before.
 15648    1    otherwise.  */
 15649 
 15650 static int
 15651 get_tool_bar_item (struct frame *f, int x, int y, struct glyph **glyph,
 15652                    int *hpos, int *vpos, int *prop_idx)
 15653 {
 15654   Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (f);
 15655   struct window *w = XWINDOW (f->tool_bar_window);
 15656   int area;
 15657 
 15658   /* Find the glyph under X/Y.  */
 15659   *glyph = x_y_to_hpos_vpos (w, x, y, hpos, vpos, 0, 0, &area);
 15660   if (*glyph == NULL)
 15661     return -1;
 15662 
 15663   /* Get the start of this tool-bar item's properties in
 15664      f->tool_bar_items.  */
 15665   if (!tool_bar_item_info (f, *glyph, prop_idx))
 15666     return -1;
 15667 
 15668   /* Is mouse on the highlighted item?  */
 15669   if (EQ (f->tool_bar_window, hlinfo->mouse_face_window)
 15670       && *vpos >= hlinfo->mouse_face_beg_row
 15671       && *vpos <= hlinfo->mouse_face_end_row
 15672       && (*vpos > hlinfo->mouse_face_beg_row
 15673           || *hpos >= hlinfo->mouse_face_beg_col)
 15674       && (*vpos < hlinfo->mouse_face_end_row
 15675           || *hpos < hlinfo->mouse_face_end_col
 15676           || hlinfo->mouse_face_past_end))
 15677     return 0;
 15678 
 15679   return 1;
 15680 }
 15681 
 15682 
 15683 /* EXPORT:
 15684    Handle mouse button event on the tool-bar of frame F, at
 15685    frame-relative coordinates X/Y.  DOWN_P is true for a button press,
 15686    false for button release.  MODIFIERS is event modifiers for button
 15687    release.  DEVICE is the device the click came from, or Qt.  */
 15688 
 15689 void
 15690 handle_tool_bar_click_with_device (struct frame *f, int x, int y, bool down_p,
 15691                                    int modifiers, Lisp_Object device)
 15692 {
 15693   Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (f);
 15694   struct window *w = XWINDOW (f->tool_bar_window);
 15695   int hpos, vpos, prop_idx;
 15696   struct glyph *glyph;
 15697   Lisp_Object enabled_p;
 15698   int ts;
 15699 
 15700   /* If not on the highlighted tool-bar item, and mouse-highlight is
 15701      non-nil, return.  This is so we generate the tool-bar button
 15702      click only when the mouse button is released on the same item as
 15703      where it was pressed.  However, when mouse-highlight is disabled,
 15704      generate the click when the button is released regardless of the
 15705      highlight, since tool-bar items are not highlighted in that
 15706      case.  */
 15707   frame_to_window_pixel_xy (w, &x, &y);
 15708   ts = get_tool_bar_item (f, x, y, &glyph, &hpos, &vpos, &prop_idx);
 15709   if (ts == -1
 15710       || (ts != 0 && !NILP (Vmouse_highlight)))
 15711     return;
 15712 
 15713   /* When mouse-highlight is off, generate the click for the item
 15714      where the button was pressed, disregarding where it was
 15715      released.  */
 15716   if (NILP (Vmouse_highlight) && !down_p)
 15717     prop_idx = f->last_tool_bar_item;
 15718 
 15719   /* If item is disabled, do nothing.  */
 15720   enabled_p = AREF (f->tool_bar_items, prop_idx + TOOL_BAR_ITEM_ENABLED_P);
 15721   if (NILP (enabled_p))
 15722     return;
 15723 
 15724   if (down_p)
 15725     {
 15726       /* Show item in pressed state.  */
 15727       if (!NILP (Vmouse_highlight))
 15728         show_mouse_face (hlinfo, DRAW_IMAGE_SUNKEN);
 15729       f->last_tool_bar_item = prop_idx;
 15730     }
 15731   else
 15732     {
 15733       Lisp_Object key, frame;
 15734       struct input_event event;
 15735       EVENT_INIT (event);
 15736 
 15737       /* Show item in released state.  */
 15738       if (!NILP (Vmouse_highlight))
 15739         show_mouse_face (hlinfo, DRAW_IMAGE_RAISED);
 15740 
 15741       key = AREF (f->tool_bar_items, prop_idx + TOOL_BAR_ITEM_KEY);
 15742 
 15743       XSETFRAME (frame, f);
 15744       event.kind = TOOL_BAR_EVENT;
 15745       event.frame_or_window = frame;
 15746       event.arg = key;
 15747       event.modifiers = modifiers;
 15748       event.device = device;
 15749       kbd_buffer_store_event (&event);
 15750       f->last_tool_bar_item = -1;
 15751     }
 15752 }
 15753 
 15754 void
 15755 handle_tool_bar_click (struct frame *f, int x, int y, bool down_p,
 15756                        int modifiers)
 15757 {
 15758   handle_tool_bar_click_with_device (f, x, y, down_p, modifiers, Qt);
 15759 }
 15760 
 15761 /* Possibly highlight a tool-bar item on frame F when mouse moves to
 15762    tool-bar window-relative coordinates X/Y.  Called from
 15763    note_mouse_highlight.  */
 15764 
 15765 static void
 15766 note_tool_bar_highlight (struct frame *f, int x, int y)
 15767 {
 15768   Lisp_Object window = f->tool_bar_window;
 15769   struct window *w = XWINDOW (window);
 15770   Display_Info *dpyinfo = FRAME_DISPLAY_INFO (f);
 15771   Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (f);
 15772   int hpos, vpos;
 15773   struct glyph *glyph;
 15774   struct glyph_row *row;
 15775   int i;
 15776   Lisp_Object enabled_p;
 15777   int prop_idx;
 15778   enum draw_glyphs_face draw = DRAW_IMAGE_RAISED;
 15779   bool mouse_down_p;
 15780   int rc;
 15781 
 15782   /* Function note_mouse_highlight is called with negative X/Y
 15783      values when mouse moves outside of the frame.  */
 15784   if (x <= 0 || y <= 0)
 15785     {
 15786       clear_mouse_face (hlinfo);
 15787       return;
 15788     }
 15789 
 15790   rc = get_tool_bar_item (f, x, y, &glyph, &hpos, &vpos, &prop_idx);
 15791   if (rc < 0)
 15792     {
 15793       /* Not on tool-bar item.  */
 15794       clear_mouse_face (hlinfo);
 15795       return;
 15796     }
 15797   else if (rc == 0)
 15798     /* On same tool-bar item as before.  */
 15799     goto set_help_echo;
 15800 
 15801   clear_mouse_face (hlinfo);
 15802 
 15803   /* Mouse is down, but on different tool-bar item?  */
 15804   mouse_down_p = (gui_mouse_grabbed (dpyinfo)
 15805                   && f == dpyinfo->last_mouse_frame);
 15806 
 15807   if (mouse_down_p && f->last_tool_bar_item != prop_idx)
 15808     return;
 15809 
 15810   draw = mouse_down_p ? DRAW_IMAGE_SUNKEN : DRAW_IMAGE_RAISED;
 15811 
 15812   /* If tool-bar item is not enabled, don't highlight it.  */
 15813   enabled_p = AREF (f->tool_bar_items, prop_idx + TOOL_BAR_ITEM_ENABLED_P);
 15814   if (!NILP (enabled_p) && !NILP (Vmouse_highlight))
 15815     {
 15816       /* Compute the x-position of the glyph.  In front and past the
 15817          image is a space.  We include this in the highlighted area.  */
 15818       row = MATRIX_ROW (w->current_matrix, vpos);
 15819       for (i = x = 0; i < hpos; ++i)
 15820         x += row->glyphs[TEXT_AREA][i].pixel_width;
 15821 
 15822       /* Record this as the current active region.  */
 15823       hlinfo->mouse_face_beg_col = hpos;
 15824       hlinfo->mouse_face_beg_row = vpos;
 15825       hlinfo->mouse_face_beg_x = x;
 15826       hlinfo->mouse_face_past_end = false;
 15827 
 15828       hlinfo->mouse_face_end_col = hpos + 1;
 15829       hlinfo->mouse_face_end_row = vpos;
 15830       hlinfo->mouse_face_end_x = x + glyph->pixel_width;
 15831       hlinfo->mouse_face_window = window;
 15832       hlinfo->mouse_face_face_id = TOOL_BAR_FACE_ID;
 15833 
 15834       /* Display it as active.  */
 15835       show_mouse_face (hlinfo, draw);
 15836     }
 15837 
 15838  set_help_echo:
 15839 
 15840   /* Set help_echo_string to a help string to display for this tool-bar item.
 15841      XTread_socket does the rest.  */
 15842   help_echo_object = help_echo_window = Qnil;
 15843   help_echo_pos = -1;
 15844   help_echo_string = AREF (f->tool_bar_items, prop_idx + TOOL_BAR_ITEM_HELP);
 15845   if (NILP (help_echo_string))
 15846     help_echo_string = AREF (f->tool_bar_items, prop_idx + TOOL_BAR_ITEM_CAPTION);
 15847 }
 15848 
 15849 #endif /* ! (HAVE_EXT_TOOL_BAR) */
 15850 
 15851 #endif /* HAVE_WINDOW_SYSTEM */
 15852 
 15853 
 15854 
 15855 /************************************************************************
 15856                          Horizontal scrolling
 15857  ************************************************************************/
 15858 
 15859 /* For all leaf windows in the window tree rooted at WINDOW, set their
 15860    hscroll value so that PT is (i) visible in the window, and (ii) so
 15861    that it is not within a certain margin at the window's left and
 15862    right border.  Value is true if any window's hscroll has been
 15863    changed.  */
 15864 
 15865 static bool
 15866 hscroll_window_tree (Lisp_Object window)
 15867 {
 15868   bool hscrolled_p = false;
 15869   bool hscroll_relative_p = FLOATP (Vhscroll_step);
 15870   int hscroll_step_abs = 0;
 15871   double hscroll_step_rel = 0;
 15872 
 15873   if (hscroll_relative_p)
 15874     {
 15875       hscroll_step_rel = XFLOAT_DATA (Vhscroll_step);
 15876       if (hscroll_step_rel < 0)
 15877         {
 15878           hscroll_relative_p = false;
 15879           hscroll_step_abs = 0;
 15880         }
 15881     }
 15882   else if (TYPE_RANGED_FIXNUMP (int, Vhscroll_step))
 15883     {
 15884       hscroll_step_abs = XFIXNUM (Vhscroll_step);
 15885       if (hscroll_step_abs < 0)
 15886         hscroll_step_abs = 0;
 15887     }
 15888   else
 15889     hscroll_step_abs = 0;
 15890 
 15891   while (WINDOWP (window))
 15892     {
 15893       struct window *w = XWINDOW (window);
 15894 
 15895       if (WINDOWP (w->contents))
 15896         hscrolled_p |= hscroll_window_tree (w->contents);
 15897       else if (w->cursor.vpos >= 0
 15898                /* Don't allow hscroll in mini-windows that display
 15899                   echo-area messages.  This is because desired_matrix
 15900                   of such windows was prepared while momentarily
 15901                   switched to an echo-area buffer, which is different
 15902                   from w->contents, and we simply cannot hscroll such
 15903                   windows safely.  */
 15904                && !(w == XWINDOW (echo_area_window)
 15905                     && !NILP (echo_area_buffer[0])))
 15906         {
 15907           int h_margin;
 15908           int text_area_width;
 15909           struct glyph_row *cursor_row;
 15910           struct glyph_row *bottom_row;
 15911 
 15912           bottom_row = MATRIX_BOTTOM_TEXT_ROW (w->desired_matrix, w);
 15913           if (w->cursor.vpos < bottom_row - w->desired_matrix->rows)
 15914             cursor_row = MATRIX_ROW (w->desired_matrix, w->cursor.vpos);
 15915           else
 15916             cursor_row = bottom_row - 1;
 15917 
 15918           if (!cursor_row->enabled_p)
 15919             {
 15920               bottom_row = MATRIX_BOTTOM_TEXT_ROW (w->current_matrix, w);
 15921               if (w->cursor.vpos < bottom_row - w->current_matrix->rows)
 15922                 cursor_row = MATRIX_ROW (w->current_matrix, w->cursor.vpos);
 15923               else
 15924                 cursor_row = bottom_row - 1;
 15925             }
 15926           bool row_r2l_p = cursor_row->reversed_p;
 15927           bool hscl = hscrolling_current_line_p (w);
 15928           int x_offset = 0;
 15929           /* When line numbers are displayed, we need to account for
 15930              the horizontal space they consume.  */
 15931           if (!NILP (Vdisplay_line_numbers))
 15932             {
 15933               struct glyph *g;
 15934               if (!row_r2l_p)
 15935                 {
 15936                   for (g = cursor_row->glyphs[TEXT_AREA];
 15937                        g < cursor_row->glyphs[TEXT_AREA]
 15938                          + cursor_row->used[TEXT_AREA];
 15939                        g++)
 15940                     {
 15941                       if (!(NILP (g->object) && g->charpos < 0))
 15942                         break;
 15943                       x_offset += g->pixel_width;
 15944                     }
 15945                 }
 15946               else
 15947                 {
 15948                   for (g = cursor_row->glyphs[TEXT_AREA]
 15949                          + cursor_row->used[TEXT_AREA];
 15950                        g > cursor_row->glyphs[TEXT_AREA];
 15951                        g--)
 15952                     {
 15953                       if (!(NILP ((g - 1)->object) && (g - 1)->charpos < 0))
 15954                         break;
 15955                       x_offset += (g - 1)->pixel_width;
 15956                     }
 15957                 }
 15958             }
 15959           if (cursor_row->truncated_on_left_p)
 15960             {
 15961               /* On TTY frames, don't count the left truncation glyph.  */
 15962               struct frame *f = XFRAME (WINDOW_FRAME (w));
 15963               x_offset -= (FRAME_TERMCAP_P (f) || FRAME_MSDOS_P (f));
 15964             }
 15965 
 15966           text_area_width = window_box_width (w, TEXT_AREA);
 15967 
 15968           /* Scroll when cursor is inside this scroll margin.  */
 15969           h_margin = (clip_to_bounds (0, hscroll_margin, 1000000)
 15970                       * WINDOW_FRAME_COLUMN_WIDTH (w));
 15971 
 15972           /* If the position of this window's point has explicitly
 15973              changed, no more suspend auto hscrolling.  */
 15974           if (w->suspend_auto_hscroll
 15975               && NILP (Fequal (Fwindow_point (window),
 15976                                Fwindow_old_point (window))))
 15977             {
 15978               w->suspend_auto_hscroll = false;
 15979               /* When hscrolling just the current line, and the rest
 15980                  of lines were temporarily hscrolled, but no longer
 15981                  are, force thorough redisplay of this window, to show
 15982                  the effect of disabling hscroll suspension immediately.  */
 15983               if (w->min_hscroll == 0 && w->hscroll > 0
 15984                   && EQ (Fbuffer_local_value (Qauto_hscroll_mode, w->contents),
 15985                          Qcurrent_line))
 15986                 SET_FRAME_GARBAGED (XFRAME (w->frame));
 15987             }
 15988 
 15989           /* Remember window point.  */
 15990           Fset_marker (w->old_pointm,
 15991                        ((w == XWINDOW (selected_window))
 15992                         ? make_fixnum (BUF_PT (XBUFFER (w->contents)))
 15993                         : Fmarker_position (w->pointm)),
 15994                        w->contents);
 15995 
 15996           if (!NILP (Fbuffer_local_value (Qauto_hscroll_mode, w->contents))
 15997               && !w->suspend_auto_hscroll
 15998               /* In some pathological cases, like restoring a window
 15999                  configuration into a frame that is much smaller than
 16000                  the one from which the configuration was saved, we
 16001                  get glyph rows whose start and end have zero buffer
 16002                  positions, which we cannot handle below.  Just skip
 16003                  such windows.  */
 16004               && (CHARPOS (cursor_row->start.pos)
 16005                   >= BUF_BEG (XBUFFER (w->contents)))
 16006               /* For left-to-right rows, hscroll when cursor is either
 16007                  (i) inside the right hscroll margin, or (ii) if it is
 16008                  inside the left margin and the window is already
 16009                  hscrolled.  */
 16010               && ((!row_r2l_p
 16011                    && ((w->hscroll && w->cursor.x <= h_margin + x_offset)
 16012                        || (cursor_row->enabled_p
 16013                            && cursor_row->truncated_on_right_p
 16014                            && (w->cursor.x >= text_area_width - h_margin))))
 16015                   /* For right-to-left rows, the logic is similar,
 16016                      except that rules for scrolling to left and right
 16017                      are reversed.  E.g., if cursor.x <= h_margin, we
 16018                      need to hscroll "to the right" unconditionally,
 16019                      and that will scroll the screen to the left so as
 16020                      to reveal the next portion of the row.  */
 16021                   || (row_r2l_p
 16022                       && ((cursor_row->enabled_p
 16023                            /* FIXME: It is confusing to set the
 16024                               truncated_on_right_p flag when R2L rows
 16025                               are actually truncated on the left.  */
 16026                            && cursor_row->truncated_on_right_p
 16027                            && w->cursor.x <= h_margin)
 16028                           || (w->hscroll
 16029                               && (w->cursor.x >= (text_area_width - h_margin
 16030                                                   - x_offset)))))
 16031                   /* This last condition is needed when moving
 16032                      vertically from an hscrolled line to a short line
 16033                      that doesn't need to be hscrolled.  If we omit
 16034                      this condition, the line from which we move will
 16035                      remain hscrolled.  */
 16036                   || (hscl
 16037                       && w->hscroll != w->min_hscroll
 16038                       && !cursor_row->truncated_on_left_p)))
 16039             {
 16040               struct it it;
 16041               ptrdiff_t hscroll;
 16042               struct buffer *saved_current_buffer;
 16043               ptrdiff_t pt;
 16044               int wanted_x;
 16045 
 16046               /* Find point in a display of infinite width.  */
 16047               saved_current_buffer = current_buffer;
 16048               current_buffer = XBUFFER (w->contents);
 16049 
 16050               if (w == XWINDOW (selected_window))
 16051                 pt = PT;
 16052               else
 16053                 pt = clip_to_bounds (BEGV, marker_position (w->pointm), ZV);
 16054 
 16055               /* Move iterator to pt starting at cursor_row->start in
 16056                  a line with infinite width.  */
 16057               init_to_row_start (&it, w, cursor_row);
 16058               if (hscl)
 16059                 it.first_visible_x = window_hscroll_limited (w, it.f)
 16060                                      * FRAME_COLUMN_WIDTH (it.f);
 16061               it.last_visible_x = DISP_INFINITY;
 16062 
 16063               ptrdiff_t nchars = pt - IT_CHARPOS (it);
 16064               if (current_buffer->long_line_optimizations_p
 16065                   && nchars > large_hscroll_threshold)
 16066                 {
 16067                   /* Special optimization for very long and truncated
 16068                      lines which need to be hscrolled far to the left:
 16069                      jump directly to the (approximate) first position
 16070                      that is visible, instead of slowly walking there.  */
 16071                   fast_move_it_horizontally (&it, nchars);
 16072                   it.current_x += nchars * FRAME_COLUMN_WIDTH (it.f);
 16073                 }
 16074               else
 16075                 move_it_in_display_line_to (&it, pt, -1, MOVE_TO_POS);
 16076               /* If the line ends in an overlay string with a newline,
 16077                  we might infloop, because displaying the window will
 16078                  want to put the cursor after the overlay, i.e. at X
 16079                  coordinate of zero on the next screen line.  So we
 16080                  use the buffer position prior to the overlay string
 16081                  instead.  */
 16082               if (it.method == GET_FROM_STRING && pt > 1)
 16083                 {
 16084                   init_to_row_start (&it, w, cursor_row);
 16085                   if (hscl)
 16086                     it.first_visible_x = (window_hscroll_limited (w, it.f)
 16087                                           * FRAME_COLUMN_WIDTH (it.f));
 16088                   if (current_buffer->long_line_optimizations_p
 16089                       && nchars > large_hscroll_threshold)
 16090                     {
 16091                       fast_move_it_horizontally (&it, nchars - 1);
 16092                       it.current_x += (nchars - 1) * FRAME_COLUMN_WIDTH (it.f);
 16093                     }
 16094                   else
 16095                     move_it_in_display_line_to (&it, pt - 1, -1, MOVE_TO_POS);
 16096                 }
 16097               current_buffer = saved_current_buffer;
 16098 
 16099               /* Position cursor in window.  */
 16100               if (!hscroll_relative_p && hscroll_step_abs == 0)
 16101                 hscroll = max (0, (it.current_x
 16102                                    - (ITERATOR_AT_END_OF_LINE_P (&it)
 16103                                       ? (text_area_width - 4 * FRAME_COLUMN_WIDTH (it.f))
 16104                                       : (text_area_width / 2))))
 16105                           / FRAME_COLUMN_WIDTH (it.f);
 16106               else if ((!row_r2l_p
 16107                         && w->cursor.x >= text_area_width - h_margin)
 16108                        || (row_r2l_p && w->cursor.x <= h_margin))
 16109                 {
 16110                   if (hscroll_relative_p)
 16111                     wanted_x = text_area_width * (1 - hscroll_step_rel)
 16112                                - h_margin;
 16113                   else
 16114                     wanted_x = text_area_width
 16115                                - hscroll_step_abs * FRAME_COLUMN_WIDTH (it.f)
 16116                                - h_margin;
 16117                   hscroll
 16118                     = max (0, it.current_x - wanted_x) / FRAME_COLUMN_WIDTH (it.f);
 16119                 }
 16120               else
 16121                 {
 16122                   if (hscroll_relative_p)
 16123                     wanted_x =
 16124                       text_area_width * hscroll_step_rel + h_margin + x_offset;
 16125                   else
 16126                     wanted_x =
 16127                       hscroll_step_abs * FRAME_COLUMN_WIDTH (it.f)
 16128                       + h_margin + x_offset;
 16129                   hscroll
 16130                     = max (0, it.current_x - wanted_x) / FRAME_COLUMN_WIDTH (it.f);
 16131                 }
 16132               hscroll = max (hscroll, w->min_hscroll);
 16133 
 16134               /* Don't prevent redisplay optimizations if hscroll
 16135                  hasn't changed, as it will unnecessarily slow down
 16136                  redisplay.  */
 16137               if (w->hscroll != hscroll
 16138                   /* When hscrolling only the current line, we need to
 16139                      report hscroll even if its value is equal to the
 16140                      previous one, because the new line might need a
 16141                      different value.  */
 16142                   || (hscl && w->last_cursor_vpos != w->cursor.vpos))
 16143                 {
 16144                   struct buffer *b = XBUFFER (w->contents);
 16145                   b->prevent_redisplay_optimizations_p = true;
 16146                   w->hscroll = hscroll;
 16147                   hscrolled_p = true;
 16148                 }
 16149             }
 16150         }
 16151 
 16152       window = w->next;
 16153     }
 16154 
 16155   /* Value is true if hscroll of any leaf window has been changed.  */
 16156   return hscrolled_p;
 16157 }
 16158 
 16159 
 16160 /* Set hscroll so that cursor is visible and not inside horizontal
 16161    scroll margins for all windows in the tree rooted at WINDOW.  See
 16162    also hscroll_window_tree above.  Value is true if any window's
 16163    hscroll has been changed.  If it has, desired matrices on the frame
 16164    of WINDOW are cleared.  */
 16165 
 16166 static bool
 16167 hscroll_windows (Lisp_Object window)
 16168 {
 16169   bool hscrolled_p = hscroll_window_tree (window);
 16170   if (hscrolled_p)
 16171     clear_desired_matrices (XFRAME (WINDOW_FRAME (XWINDOW (window))));
 16172   return hscrolled_p;
 16173 }
 16174 
 16175 
 16176 
 16177 /************************************************************************
 16178                                 Redisplay
 16179  ************************************************************************/
 16180 
 16181 /* Variables holding some state of redisplay if GLYPH_DEBUG is defined.
 16182    This is sometimes handy to have in a debugger session.  */
 16183 
 16184 #ifdef GLYPH_DEBUG
 16185 
 16186 /* First and last unchanged row for try_window_id.  */
 16187 
 16188 static int debug_first_unchanged_at_end_vpos;
 16189 static int debug_last_unchanged_at_beg_vpos;
 16190 
 16191 /* Delta vpos and y.  */
 16192 
 16193 static int debug_dvpos, debug_dy;
 16194 
 16195 /* Delta in characters and bytes for try_window_id.  */
 16196 
 16197 static ptrdiff_t debug_delta, debug_delta_bytes;
 16198 
 16199 /* Values of window_end_pos and window_end_vpos at the end of
 16200    try_window_id.  */
 16201 
 16202 static ptrdiff_t debug_end_vpos;
 16203 
 16204 /* Append a string to W->desired_matrix->method.  FMT is a printf
 16205    format string.  If trace_redisplay_p is true also printf the
 16206    resulting string to stderr.  */
 16207 
 16208 static void debug_method_add (struct window *, char const *, ...)
 16209   ATTRIBUTE_FORMAT_PRINTF (2, 3);
 16210 
 16211 static void
 16212 debug_method_add (struct window *w, char const *fmt, ...)
 16213 {
 16214   void *ptr = w;
 16215   char *method = w->desired_matrix->method;
 16216   int len = strlen (method);
 16217   int size = sizeof w->desired_matrix->method;
 16218   int remaining = size - len - 1;
 16219   va_list ap;
 16220 
 16221   if (len && remaining)
 16222     {
 16223       method[len] = '|';
 16224       --remaining, ++len;
 16225     }
 16226 
 16227   va_start (ap, fmt);
 16228   vsnprintf (method + len, remaining + 1, fmt, ap);
 16229   va_end (ap);
 16230 
 16231   if (trace_redisplay_p)
 16232     fprintf (stderr, "%p (%s): %s\n",
 16233              ptr,
 16234              ((BUFFERP (w->contents)
 16235                && STRINGP (BVAR (XBUFFER (w->contents), name)))
 16236               ? SSDATA (BVAR (XBUFFER (w->contents), name))
 16237               : "no buffer"),
 16238              method + len);
 16239 }
 16240 
 16241 #endif /* GLYPH_DEBUG */
 16242 
 16243 
 16244 /* Value is true if all changes in window W, which displays
 16245    current_buffer, are in the text between START and END.  START is a
 16246    buffer position, END is given as a distance from Z.  Used in
 16247    redisplay_internal for display optimization.  */
 16248 
 16249 static bool
 16250 text_outside_line_unchanged_p (struct window *w,
 16251                                ptrdiff_t start, ptrdiff_t end)
 16252 {
 16253   bool unchanged_p = true;
 16254 
 16255   /* If text or overlays have changed, see where.  */
 16256   if (window_outdated (w))
 16257     {
 16258       /* Gap in the line?  */
 16259       if (GPT < start || Z - GPT < end)
 16260         unchanged_p = false;
 16261 
 16262       /* Changes start in front of the line, or end after it?  */
 16263       if (unchanged_p
 16264           && (BEG_UNCHANGED < start - 1
 16265               || END_UNCHANGED < end))
 16266         unchanged_p = false;
 16267 
 16268       /* If selective display, can't optimize if changes start at the
 16269          beginning of the line.  */
 16270       if (unchanged_p
 16271           && FIXNUMP (BVAR (current_buffer, selective_display))
 16272           && XFIXNUM (BVAR (current_buffer, selective_display)) > 0
 16273           && (BEG_UNCHANGED < start || GPT <= start))
 16274         unchanged_p = false;
 16275 
 16276       /* If there are overlays at the start or end of the line, these
 16277          may have overlay strings with newlines in them.  A change at
 16278          START, for instance, may actually concern the display of such
 16279          overlay strings as well, and they are displayed on different
 16280          lines.  So, quickly rule out this case.  (For the future, it
 16281          might be desirable to implement something more telling than
 16282          just BEG/END_UNCHANGED.)  */
 16283       if (unchanged_p)
 16284         {
 16285           if (BEG + BEG_UNCHANGED == start
 16286               && overlay_touches_p (start))
 16287             unchanged_p = false;
 16288           if (END_UNCHANGED == end
 16289               && overlay_touches_p (Z - end))
 16290             unchanged_p = false;
 16291         }
 16292 
 16293       /* Under bidi reordering, adding or deleting a character in the
 16294          beginning of a paragraph, before the first strong directional
 16295          character, can change the base direction of the paragraph (unless
 16296          the buffer specifies a fixed paragraph direction), which will
 16297          require redisplaying the whole paragraph.  It might be worthwhile
 16298          to find the paragraph limits and widen the range of redisplayed
 16299          lines to that, but for now just give up this optimization.  */
 16300       if (!NILP (BVAR (XBUFFER (w->contents), bidi_display_reordering))
 16301           && NILP (BVAR (XBUFFER (w->contents), bidi_paragraph_direction)))
 16302         unchanged_p = false;
 16303     }
 16304 
 16305   return unchanged_p;
 16306 }
 16307 
 16308 
 16309 /* Do a frame update, taking possible shortcuts into account.  This is
 16310    the main external entry point for redisplay.
 16311 
 16312    If the last redisplay displayed an echo area message and that message
 16313    is no longer requested, we clear the echo area or bring back the
 16314    mini-buffer if that is in use.  */
 16315 
 16316 void
 16317 redisplay (void)
 16318 {
 16319   redisplay_internal ();
 16320 }
 16321 
 16322 
 16323 static Lisp_Object
 16324 overlay_arrow_string_or_property (Lisp_Object var)
 16325 {
 16326   Lisp_Object val;
 16327 
 16328   if (val = Fget (var, Qoverlay_arrow_string), STRINGP (val))
 16329     return val;
 16330 
 16331   return Voverlay_arrow_string;
 16332 }
 16333 
 16334 /* Return true if there are any overlay-arrows in current_buffer.  */
 16335 static bool
 16336 overlay_arrow_in_current_buffer_p (void)
 16337 {
 16338   Lisp_Object vlist;
 16339 
 16340   for (vlist = Voverlay_arrow_variable_list;
 16341        CONSP (vlist);
 16342        vlist = XCDR (vlist))
 16343     {
 16344       Lisp_Object var = XCAR (vlist);
 16345       Lisp_Object val;
 16346 
 16347       if (!SYMBOLP (var))
 16348         continue;
 16349       val = find_symbol_value (var);
 16350       if (MARKERP (val)
 16351           && current_buffer == XMARKER (val)->buffer)
 16352         return true;
 16353     }
 16354   return false;
 16355 }
 16356 
 16357 
 16358 /* Return true if any overlay_arrows have moved or overlay-arrow-string
 16359    has changed.
 16360    If SET_REDISPLAY is true, additionally, set the `redisplay' bit in those
 16361    buffers that are affected.  */
 16362 
 16363 static bool
 16364 overlay_arrows_changed_p (bool set_redisplay)
 16365 {
 16366   Lisp_Object vlist;
 16367   bool changed = false;
 16368 
 16369   for (vlist = Voverlay_arrow_variable_list;
 16370        CONSP (vlist);
 16371        vlist = XCDR (vlist))
 16372     {
 16373       Lisp_Object var = XCAR (vlist);
 16374       Lisp_Object val, pstr;
 16375 
 16376       if (!SYMBOLP (var))
 16377         continue;
 16378       val = find_symbol_value (var);
 16379       if (!MARKERP (val))
 16380         continue;
 16381       if (! EQ (Fmarker_position (val),
 16382                 /* FIXME: Don't we have a problem, using such a global
 16383                  * "last-position" if the variable is buffer-local?  */
 16384                 Fget (var, Qlast_arrow_position))
 16385           || ! (pstr = overlay_arrow_string_or_property (var),
 16386                 EQ (pstr, Fget (var, Qlast_arrow_string))))
 16387         {
 16388           struct buffer *buf = XMARKER (val)->buffer;
 16389 
 16390           if (set_redisplay)
 16391             {
 16392               if (buf)
 16393                 bset_redisplay (buf);
 16394               changed = true;
 16395             }
 16396           else
 16397             return true;
 16398         }
 16399     }
 16400   return changed;
 16401 }
 16402 
 16403 /* Mark overlay arrows to be updated on next redisplay.  */
 16404 
 16405 static void
 16406 update_overlay_arrows (int up_to_date)
 16407 {
 16408   Lisp_Object vlist;
 16409 
 16410   for (vlist = Voverlay_arrow_variable_list;
 16411        CONSP (vlist);
 16412        vlist = XCDR (vlist))
 16413     {
 16414       Lisp_Object var = XCAR (vlist);
 16415 
 16416       if (!SYMBOLP (var))
 16417         continue;
 16418 
 16419       if (up_to_date > 0)
 16420         {
 16421           Lisp_Object val = find_symbol_value (var);
 16422           if (!MARKERP (val))
 16423             continue;
 16424           Fput (var, Qlast_arrow_position, Fmarker_position (val));
 16425           Fput (var, Qlast_arrow_string,
 16426                 overlay_arrow_string_or_property (var));
 16427         }
 16428       else if (up_to_date < 0
 16429                || !NILP (Fget (var, Qlast_arrow_position)))
 16430         {
 16431           Fput (var, Qlast_arrow_position, Qt);
 16432           Fput (var, Qlast_arrow_string, Qt);
 16433         }
 16434     }
 16435 }
 16436 
 16437 
 16438 /* Return overlay arrow string to display at row.
 16439    Return integer (bitmap number) for arrow bitmap in left fringe.
 16440    Return nil if no overlay arrow.  */
 16441 
 16442 static Lisp_Object
 16443 overlay_arrow_at_row (struct it *it, struct glyph_row *row)
 16444 {
 16445   Lisp_Object vlist;
 16446 
 16447   for (vlist = Voverlay_arrow_variable_list;
 16448        CONSP (vlist);
 16449        vlist = XCDR (vlist))
 16450     {
 16451       Lisp_Object var = XCAR (vlist);
 16452       Lisp_Object val;
 16453 
 16454       if (!SYMBOLP (var))
 16455         continue;
 16456 
 16457       val = find_symbol_value (var);
 16458 
 16459       if (MARKERP (val)
 16460           && current_buffer == XMARKER (val)->buffer
 16461           && (MATRIX_ROW_START_CHARPOS (row) == marker_position (val)))
 16462         {
 16463           if (FRAME_WINDOW_P (it->f)
 16464               /* FIXME: if ROW->reversed_p is set, this should test
 16465                  the right fringe, not the left one.  */
 16466               && WINDOW_LEFT_FRINGE_WIDTH (it->w) > 0)
 16467             {
 16468 #ifdef HAVE_WINDOW_SYSTEM
 16469               if (val = Fget (var, Qoverlay_arrow_bitmap), SYMBOLP (val))
 16470                 {
 16471                   int fringe_bitmap = lookup_fringe_bitmap (val);
 16472                   if (fringe_bitmap != 0)
 16473                     return make_fixnum (fringe_bitmap);
 16474                 }
 16475 #endif
 16476               return make_fixnum (-1); /* Use default arrow bitmap.  */
 16477             }
 16478           return overlay_arrow_string_or_property (var);
 16479         }
 16480     }
 16481 
 16482   return Qnil;
 16483 }
 16484 
 16485 /* Return true if point moved out of or into a composition.  Otherwise
 16486    return false.  PREV_BUF and PREV_PT are the last point buffer and
 16487    position.  BUF and PT are the current point buffer and position.  */
 16488 
 16489 static bool
 16490 check_point_in_composition (struct buffer *prev_buf, ptrdiff_t prev_pt,
 16491                             struct buffer *buf, ptrdiff_t pt)
 16492 {
 16493   ptrdiff_t start, end;
 16494   Lisp_Object prop;
 16495   Lisp_Object buffer;
 16496 
 16497   XSETBUFFER (buffer, buf);
 16498   /* Check a composition at the last point if point moved within the
 16499      same buffer.  */
 16500   if (prev_buf == buf)
 16501     {
 16502       if (prev_pt == pt)
 16503         /* Point didn't move.  */
 16504         return false;
 16505 
 16506       if (prev_pt > BUF_BEGV (buf) && prev_pt < BUF_ZV (buf)
 16507           && find_composition (prev_pt, -1, &start, &end, &prop, buffer)
 16508           && composition_valid_p (start, end, prop)
 16509           && start < prev_pt && end > prev_pt)
 16510         /* The last point was within the composition.  Return true iff
 16511             point moved out of the composition.  */
 16512         return (pt <= start || pt >= end);
 16513     }
 16514 
 16515   /* Check a composition at the current point.  */
 16516   return (pt > BUF_BEGV (buf) && pt < BUF_ZV (buf)
 16517           && find_composition (pt, -1, &start, &end, &prop, buffer)
 16518           && composition_valid_p (start, end, prop)
 16519           && start < pt && end > pt);
 16520 }
 16521 
 16522 /* Reconsider the clip changes of buffer which is displayed in W.  */
 16523 
 16524 static void
 16525 reconsider_clip_changes (struct window *w)
 16526 {
 16527   struct buffer *b = XBUFFER (w->contents);
 16528 
 16529   if (b->clip_changed
 16530       && w->window_end_valid
 16531       && w->current_matrix->buffer == b
 16532       && w->current_matrix->zv == BUF_ZV (b)
 16533       && w->current_matrix->begv == BUF_BEGV (b))
 16534     b->clip_changed = false;
 16535 
 16536   /* If display wasn't paused, and W is not a tool bar window, see if
 16537      point has been moved into or out of a composition.  In that case,
 16538      set b->clip_changed to force updating the screen.  If
 16539      b->clip_changed has already been set, skip this check.  */
 16540   if (!b->clip_changed && w->window_end_valid)
 16541     {
 16542       ptrdiff_t pt = (w == XWINDOW (selected_window)
 16543                       ? PT : marker_position (w->pointm));
 16544 
 16545       if ((w->current_matrix->buffer != b || pt != w->last_point)
 16546           && check_point_in_composition (w->current_matrix->buffer,
 16547                                          w->last_point, b, pt))
 16548         b->clip_changed = true;
 16549     }
 16550 }
 16551 
 16552 static void
 16553 propagate_buffer_redisplay (void)
 16554 { /* Resetting b->text->redisplay is problematic!
 16555      We can't just reset it in the case that some window that displays
 16556      it has not been redisplayed; and such a window can stay
 16557      unredisplayed for a long time if it's currently invisible.
 16558      But we do want to reset it at the end of redisplay otherwise
 16559      its displayed windows will keep being redisplayed over and over
 16560      again.
 16561      So we copy all b->text->redisplay flags up to their windows here,
 16562      such that mark_window_display_accurate can safely reset
 16563      b->text->redisplay.  */
 16564   Lisp_Object ws = window_list ();
 16565   for (; CONSP (ws); ws = XCDR (ws))
 16566     {
 16567       struct window *thisw = XWINDOW (XCAR (ws));
 16568       struct buffer *thisb = XBUFFER (thisw->contents);
 16569       if (thisb->text->redisplay)
 16570         thisw->redisplay = true;
 16571     }
 16572 }
 16573 
 16574 #define STOP_POLLING                                    \
 16575 do { if (! polling_stopped_here) stop_polling ();       \
 16576        polling_stopped_here = true; } while (false)
 16577 
 16578 #define RESUME_POLLING                                  \
 16579 do { if (polling_stopped_here) start_polling ();        \
 16580        polling_stopped_here = false; } while (false)
 16581 
 16582 /* Perhaps in the future avoid recentering windows if it
 16583    is not necessary; currently that causes some problems.  */
 16584 
 16585 static void
 16586 redisplay_internal (void)
 16587 {
 16588   struct window *w = XWINDOW (selected_window);
 16589   struct window *sw;
 16590   struct frame *fr;
 16591   bool pending;
 16592   bool must_finish = false, match_p;
 16593   struct text_pos tlbufpos, tlendpos;
 16594   int number_of_visible_frames;
 16595   struct frame *sf;
 16596   bool polling_stopped_here = false;
 16597   Lisp_Object tail, frame;
 16598 
 16599   /* Set a limit to the number of retries we perform due to horizontal
 16600      scrolling, this avoids getting stuck in an uninterruptible
 16601      infinite loop (Bug #24633).  */
 16602   enum { MAX_HSCROLL_RETRIES = 16 };
 16603   int hscroll_retries = 0;
 16604 
 16605   /* Limit the number of retries for when frame(s) become garbaged as
 16606      result of redisplaying them.  Some packages set various redisplay
 16607      hooks, such as window-scroll-functions, to run Lisp that always
 16608      calls APIs which cause the frame's garbaged flag to become set,
 16609      so we loop indefinitely.  */
 16610   enum {MAX_GARBAGED_FRAME_RETRIES = 2 };
 16611   int garbaged_frame_retries = 0;
 16612 
 16613   /* True means redisplay has to consider all windows on all
 16614      frames.  False, only selected_window is considered.  */
 16615   bool consider_all_windows_p;
 16616 
 16617   /* True means redisplay has to redisplay the miniwindow.  */
 16618   bool update_miniwindow_p = false;
 16619 
 16620   redisplay_trace ("redisplay_internal %d\n", redisplaying_p);
 16621 
 16622   /* No redisplay if running in batch mode or frame is not yet fully
 16623      initialized, or redisplay is explicitly turned off by setting
 16624      Vinhibit_redisplay.  */
 16625   if ((FRAME_INITIAL_P (SELECTED_FRAME ())
 16626        && redisplay_skip_initial_frame)
 16627       || !NILP (Vinhibit_redisplay))
 16628     return;
 16629 
 16630   /* Don't examine these until after testing Vinhibit_redisplay.
 16631      When Emacs is shutting down, perhaps because its connection to
 16632      X has dropped, we should not look at them at all.  */
 16633   fr = XFRAME (w->frame);
 16634   sf = SELECTED_FRAME ();
 16635 
 16636   if (!fr->glyphs_initialized_p)
 16637     return;
 16638 
 16639 #if defined (USE_X_TOOLKIT) || defined (USE_GTK) || defined (HAVE_NS)
 16640   if (popup_activated ())
 16641     return;
 16642 #endif
 16643 
 16644 #if defined (HAVE_HAIKU)
 16645   if (popup_activated_p)
 16646     return;
 16647 #endif
 16648 
 16649   /* I don't think this happens but let's be paranoid.  */
 16650   if (redisplaying_p)
 16651     return;
 16652 
 16653   /* Record a function that clears redisplaying_p
 16654      when we leave this function.  */
 16655   specpdl_ref count = SPECPDL_INDEX ();
 16656   record_unwind_protect_void (unwind_redisplay);
 16657   redisplaying_p = true;
 16658   block_buffer_flips ();
 16659   specbind (Qinhibit_free_realized_faces, Qnil);
 16660 
 16661   /* Record this function, so it appears on the profiler's backtraces.  */
 16662   record_in_backtrace (Qredisplay_internal_xC_functionx, 0, 0);
 16663 
 16664   FOR_EACH_FRAME (tail, frame)
 16665     XFRAME (frame)->already_hscrolled_p = false;
 16666 
 16667   reset_outermost_restrictions ();
 16668 
 16669  retry:
 16670   /* Remember the currently selected window.  */
 16671   sw = w;
 16672 
 16673   pending = false;
 16674   forget_escape_and_glyphless_faces ();
 16675 
 16676   inhibit_free_realized_faces = false;
 16677 
 16678   /* If face_change, init_iterator will free all realized faces, which
 16679      includes the faces referenced from current matrices.  So, we
 16680      can't reuse current matrices in this case.  */
 16681   if (face_change)
 16682     windows_or_buffers_changed = 47;
 16683 
 16684   if ((FRAME_TERMCAP_P (sf) || FRAME_MSDOS_P (sf))
 16685       && FRAME_TTY (sf)->previous_frame != sf)
 16686     {
 16687       /* Since frames on a single ASCII terminal share the same
 16688          display area, displaying a different frame means redisplay
 16689          the whole thing.  */
 16690       SET_FRAME_GARBAGED (sf);
 16691 #if !defined DOS_NT && !defined HAVE_ANDROID
 16692       set_tty_color_mode (FRAME_TTY (sf), sf);
 16693 #endif
 16694       FRAME_TTY (sf)->previous_frame = sf;
 16695     }
 16696 
 16697   /* Set the visible flags for all frames.  Do this before checking for
 16698      resized or garbaged frames; they want to know if their frames are
 16699      visible.  See the comment in frame.h for FRAME_SAMPLE_VISIBILITY.  */
 16700   number_of_visible_frames = 0;
 16701 
 16702   FOR_EACH_FRAME (tail, frame)
 16703     {
 16704       struct frame *f = XFRAME (frame);
 16705 
 16706       if (FRAME_REDISPLAY_P (f))
 16707         {
 16708           ++number_of_visible_frames;
 16709           /* Adjust matrices for visible frames only.  */
 16710           if (f->fonts_changed)
 16711             {
 16712               adjust_frame_glyphs (f);
 16713               /* Disable all redisplay optimizations for this frame.
 16714                  This is because adjust_frame_glyphs resets the
 16715                  enabled_p flag for all glyph rows of all windows, so
 16716                  many optimizations will fail anyway, and some might
 16717                  fail to test that flag and do bogus things as
 16718                  result.  */
 16719               SET_FRAME_GARBAGED (f);
 16720               f->fonts_changed = false;
 16721             }
 16722           /* If cursor type has been changed on the frame
 16723              other than selected, consider all frames.  */
 16724           if (f != sf && f->cursor_type_changed)
 16725             fset_redisplay (f);
 16726         }
 16727       clear_desired_matrices (f);
 16728     }
 16729 
 16730   /* Notice any pending interrupt request to change frame size.  */
 16731   do_pending_window_change (true);
 16732 
 16733   /* Clear frames marked as garbaged.  */
 16734   clear_garbaged_frames ();
 16735 
 16736   /* Build menubar and tool-bar items.  */
 16737   if (NILP (Vmemory_full))
 16738     prepare_menu_bars ();
 16739 
 16740   /* do_pending_window_change could change the selected_window due to
 16741      frame resizing which makes the selected window too small.
 16742      prepare_menu_bars may call lisp hooks and hence also change the
 16743      selected_window.  */
 16744   if (WINDOWP (selected_window) && (w = XWINDOW (selected_window)) != sw)
 16745     sw = w;
 16746 
 16747   reconsider_clip_changes (w);
 16748 
 16749   /* In most cases selected window displays current buffer.  */
 16750   match_p = XBUFFER (w->contents) == current_buffer;
 16751   if (match_p)
 16752     {
 16753       /* Detect case that we need to write or remove a star in the mode line.  */
 16754       if ((SAVE_MODIFF < MODIFF) != w->last_had_star)
 16755         w->update_mode_line = true;
 16756 
 16757       if (mode_line_update_needed (w))
 16758         w->update_mode_line = true;
 16759 
 16760       /* If reconsider_clip_changes above decided that the narrowing
 16761          in the current buffer changed, make sure all other windows
 16762          showing that buffer will be redisplayed.  */
 16763       if (current_buffer->clip_changed)
 16764         bset_update_mode_line (current_buffer);
 16765     }
 16766 
 16767   /* Normally the message* functions will have already displayed and
 16768      updated the echo area, but the frame may have been trashed, or
 16769      the update may have been preempted, so display the echo area
 16770      again here.  Checking message_cleared_p captures the case that
 16771      the echo area should be cleared.  */
 16772   if ((!NILP (echo_area_buffer[0]) && !display_last_displayed_message_p)
 16773       || (!NILP (echo_area_buffer[1]) && display_last_displayed_message_p)
 16774       || (message_cleared_p
 16775           && minibuf_level == 0
 16776           /* If the mini-window is currently selected, this means the
 16777              echo-area doesn't show through.  */
 16778           && !MINI_WINDOW_P (XWINDOW (selected_window))))
 16779     {
 16780       echo_area_display (false);
 16781 
 16782       if (message_cleared_p)
 16783         update_miniwindow_p = true;
 16784 
 16785       must_finish = true;
 16786 
 16787       /* If we don't display the current message, don't clear the
 16788          message_cleared_p flag, because, if we did, we wouldn't clear
 16789          the echo area in the next redisplay which doesn't preserve
 16790          the echo area.  */
 16791       if (!display_last_displayed_message_p)
 16792         message_cleared_p = false;
 16793     }
 16794   else if (EQ (selected_window, minibuf_window)
 16795            && (current_buffer->clip_changed || window_outdated (w))
 16796            && resize_mini_window (w, false))
 16797     {
 16798       /* Resized active mini-window to fit the size of what it is
 16799          showing if its contents might have changed.  */
 16800       must_finish = true;
 16801 
 16802       /* If window configuration was changed, frames may have been
 16803          marked garbaged.  Clear them or we will experience
 16804          surprises wrt scrolling.  */
 16805       clear_garbaged_frames ();
 16806     }
 16807 
 16808   if (!NILP (Vrun_hooks))
 16809     run_window_change_functions ();
 16810 
 16811   if (windows_or_buffers_changed && !update_mode_lines)
 16812     /* Code that sets windows_or_buffers_changed doesn't distinguish whether
 16813        only the windows's contents needs to be refreshed, or whether the
 16814        mode-lines also need a refresh.  */
 16815     update_mode_lines = (windows_or_buffers_changed == REDISPLAY_SOME
 16816                          ? REDISPLAY_SOME : 32);
 16817 
 16818   /* If specs for an arrow have changed, do thorough redisplay
 16819      to ensure we remove any arrow that should no longer exist.  */
 16820   /* Apparently, this is the only case where we update other windows,
 16821      without updating other mode-lines.  */
 16822   overlay_arrows_changed_p (true);
 16823 
 16824   consider_all_windows_p = (update_mode_lines
 16825                             || windows_or_buffers_changed);
 16826 
 16827 #define AINC(a,i)                                                       \
 16828   {                                                                     \
 16829     Lisp_Object entry = Fgethash (make_fixnum (i), a, make_fixnum (0)); \
 16830     if (FIXNUMP (entry))                                                \
 16831       Fputhash (make_fixnum (i), make_fixnum (1 + XFIXNUM (entry)), a); \
 16832   }
 16833 
 16834   AINC (Vredisplay__all_windows_cause, windows_or_buffers_changed);
 16835   AINC (Vredisplay__mode_lines_cause, update_mode_lines);
 16836 
 16837   /* Optimize the case that only the line containing the cursor in the
 16838      selected window has changed.  Variables starting with this_ are
 16839      set in display_line and record information about the line
 16840      containing the cursor.  */
 16841   tlbufpos = this_line_start_pos;
 16842   tlendpos = this_line_end_pos;
 16843   if (!consider_all_windows_p
 16844       && CHARPOS (tlbufpos) > 0
 16845       && !w->update_mode_line
 16846       && !current_buffer->clip_changed
 16847       && !current_buffer->prevent_redisplay_optimizations_p
 16848       && FRAME_REDISPLAY_P (XFRAME (w->frame))
 16849       && !FRAME_OBSCURED_P (XFRAME (w->frame))
 16850       && !XFRAME (w->frame)->cursor_type_changed
 16851       && !XFRAME (w->frame)->face_change
 16852       /* Make sure recorded data applies to current buffer, etc.  */
 16853       && this_line_buffer == current_buffer
 16854       && match_p
 16855       && !w->force_start
 16856       && !w->optional_new_start
 16857       /* Point must be on the line that we have info recorded about.  */
 16858       && PT >= CHARPOS (tlbufpos)
 16859       && PT <= Z - CHARPOS (tlendpos)
 16860       /* FIXME: The following condition is only needed when
 16861          significant parts of the buffer are hidden (e.g., under
 16862          hs-minor-mode), but there doesn't seem to be a simple way of
 16863          detecting that, so we always disable the one-line redisplay
 16864          optimizations whenever display-line-numbers-mode is turned on
 16865          in the buffer.  */
 16866       && (NILP (Vdisplay_line_numbers)
 16867           || EQ (Vdisplay_line_numbers, Qvisual))
 16868       /* All text outside that line, including its final newline,
 16869          must be unchanged.  */
 16870       && text_outside_line_unchanged_p (w, CHARPOS (tlbufpos),
 16871                                         CHARPOS (tlendpos)))
 16872     {
 16873       if (CHARPOS (tlbufpos) > BEGV
 16874           && FETCH_BYTE (BYTEPOS (tlbufpos) - 1) != '\n'
 16875           && (CHARPOS (tlbufpos) == ZV
 16876               || FETCH_BYTE (BYTEPOS (tlbufpos)) == '\n'))
 16877         /* Former continuation line has disappeared by becoming empty.  */
 16878         goto cancel;
 16879       else if (window_outdated (w) || MINI_WINDOW_P (w))
 16880         {
 16881           /* We have to handle the case of continuation around a
 16882              wide-column character (see the comment in indent.c around
 16883              line 1340).
 16884 
 16885              For instance, in the following case:
 16886 
 16887              --------  Insert  --------
 16888              K_A_N_\\   `a'    K_A_N_a\         `X_' are wide-column chars.
 16889              J_I_       ==>    J_I_             `^^' are cursors.
 16890              ^^                ^^
 16891              --------          --------
 16892 
 16893              As we have to redraw the line above, we cannot use this
 16894              optimization.  */
 16895 
 16896           struct it it;
 16897           int line_height_before = this_line_pixel_height;
 16898 
 16899           /* Note that start_display will handle the case that the
 16900              line starting at tlbufpos is a continuation line.  */
 16901           start_display (&it, w, tlbufpos);
 16902 
 16903           /* Implementation note: It this still necessary?  */
 16904           if (it.current_x != this_line_start_x)
 16905             goto cancel;
 16906 
 16907           /* Give up on this optimization if the line starts with a
 16908              string with display property that draws on the fringes,
 16909              as that might interfere with line-prefix display.  */
 16910           if (it.sp > 1
 16911               && it.method == GET_FROM_IMAGE && it.image_id == -1)
 16912             goto cancel;
 16913           redisplay_trace ("trying display optimization 1\n");
 16914           w->cursor.vpos = -1;
 16915           overlay_arrow_seen = false;
 16916           it.vpos = this_line_vpos;
 16917           it.current_y = this_line_y;
 16918           it.glyph_row = MATRIX_ROW (w->desired_matrix, this_line_vpos);
 16919           display_line (&it, -1);
 16920 
 16921           /* If line contains point, is not continued,
 16922              and ends at same distance from eob as before, we win.  */
 16923           if (w->cursor.vpos >= 0
 16924               /* Line is not continued, otherwise this_line_start_pos
 16925                  would have been set to 0 in display_line.  */
 16926               && CHARPOS (this_line_start_pos)
 16927               /* Line ends as before.  */
 16928               && CHARPOS (this_line_end_pos) == CHARPOS (tlendpos)
 16929               /* Line has same height as before.  Otherwise other lines
 16930                  would have to be shifted up or down.  */
 16931               && this_line_pixel_height == line_height_before
 16932               /* Cannot use this optimization if hscrolling current
 16933                  line and this line is the current one, because
 16934                  display_line above is not informed about the
 16935                  current-line's vpos, and cannot DTRT in that case.  */
 16936               && !hscrolling_current_line_p (w))
 16937             {
 16938               /* If this is not the window's last line, we must adjust
 16939                  the charstarts of the lines below.  */
 16940               if (it.current_y < it.last_visible_y)
 16941                 {
 16942                   struct glyph_row *row
 16943                     = MATRIX_ROW (w->current_matrix, this_line_vpos + 1);
 16944                   ptrdiff_t delta, delta_bytes;
 16945 
 16946                   /* We used to distinguish between two cases here,
 16947                      conditioned by Z - CHARPOS (tlendpos) == ZV, for
 16948                      when the line ends in a newline or the end of the
 16949                      buffer's accessible portion.  But both cases did
 16950                      the same, so they were collapsed.  */
 16951                   delta = (Z
 16952                            - CHARPOS (tlendpos)
 16953                            - MATRIX_ROW_START_CHARPOS (row));
 16954                   delta_bytes = (Z_BYTE
 16955                                  - BYTEPOS (tlendpos)
 16956                                  - MATRIX_ROW_START_BYTEPOS (row));
 16957 
 16958                   increment_matrix_positions (w->current_matrix,
 16959                                               this_line_vpos + 1,
 16960                                               w->current_matrix->nrows,
 16961                                               delta, delta_bytes);
 16962                 }
 16963 
 16964               /* If this row displays text now but previously didn't,
 16965                  or vice versa, w->window_end_vpos may have to be
 16966                  adjusted.  */
 16967               if (MATRIX_ROW_DISPLAYS_TEXT_P (it.glyph_row - 1))
 16968                 {
 16969                   if (w->window_end_vpos < this_line_vpos)
 16970                     w->window_end_vpos = this_line_vpos;
 16971                 }
 16972               else if (w->window_end_vpos == this_line_vpos
 16973                        && this_line_vpos > 0)
 16974                 w->window_end_vpos = this_line_vpos - 1;
 16975               w->window_end_valid = false;
 16976 
 16977               /* Update hint: No need to try to scroll in update_window.  */
 16978               w->desired_matrix->no_scrolling_p = true;
 16979 
 16980 #ifdef GLYPH_DEBUG
 16981               *w->desired_matrix->method = 0;
 16982               debug_method_add (w, "optimization 1");
 16983 #endif
 16984 #ifdef HAVE_WINDOW_SYSTEM
 16985               update_window_fringes (w, false);
 16986 #endif
 16987               goto update;
 16988             }
 16989           else
 16990             goto cancel;
 16991         }
 16992       else if (/* Cursor position hasn't changed.  */
 16993                PT == w->last_point
 16994                /* Make sure the cursor was last displayed
 16995                   in this window.  Otherwise we have to reposition it.  */
 16996 
 16997                /* PXW: Must be converted to pixels, probably.  */
 16998                && 0 <= w->cursor.vpos
 16999                && w->cursor.vpos < WINDOW_TOTAL_LINES (w))
 17000         {
 17001           if (!must_finish)
 17002             {
 17003               do_pending_window_change (true);
 17004               /* If selected_window changed, redisplay again.  */
 17005               if (WINDOWP (selected_window)
 17006                   && (w = XWINDOW (selected_window)) != sw)
 17007                 goto retry;
 17008 
 17009                 /* We used to always goto end_of_redisplay here, but this
 17010                  isn't enough if we have a blinking cursor.  */
 17011               if (w->cursor_off_p == w->last_cursor_off_p)
 17012                 goto end_of_redisplay;
 17013             }
 17014           goto update;
 17015         }
 17016       /* If highlighting the region, or if the cursor is in the echo area,
 17017          then we can't just move the cursor.  */
 17018       else if (NILP (Vshow_trailing_whitespace)
 17019                && !cursor_in_echo_area
 17020                && !composition_break_at_point)
 17021         {
 17022           struct it it;
 17023           struct glyph_row *row;
 17024 
 17025           /* Skip from tlbufpos to PT and see where it is.  Note that
 17026              PT may be in invisible text.  If so, we will end at the
 17027              next visible position.  */
 17028           init_iterator (&it, w, CHARPOS (tlbufpos), BYTEPOS (tlbufpos),
 17029                          NULL, DEFAULT_FACE_ID);
 17030           it.current_x = this_line_start_x;
 17031           it.current_y = this_line_y;
 17032           it.vpos = this_line_vpos;
 17033 
 17034           if (current_buffer->long_line_optimizations_p
 17035               && it.line_wrap == TRUNCATE
 17036               && PT - CHARPOS (tlbufpos) > large_hscroll_threshold)
 17037             {
 17038               /* When lines are very long and truncated, jumping to
 17039                  the next visible line is much faster than slowly
 17040                  iterating there.  */
 17041               reseat_at_next_visible_line_start (&it, false);
 17042               if (IT_CHARPOS (it) <= PT) /* point moved off this line */
 17043                 it.vpos = this_line_vpos + 1;
 17044             }
 17045           else
 17046             {
 17047               /* The call to move_it_to stops in front of PT, but
 17048                  moves over before-strings.  */
 17049               move_it_to (&it, PT, -1, -1, -1, MOVE_TO_POS);
 17050             }
 17051 
 17052           if (it.vpos == this_line_vpos
 17053               && (row = MATRIX_ROW (w->current_matrix, this_line_vpos),
 17054                   row->enabled_p))
 17055             {
 17056               eassert (this_line_vpos == it.vpos);
 17057               eassert (this_line_y == it.current_y);
 17058               set_cursor_from_row (w, row, w->current_matrix, 0, 0, 0, 0);
 17059               if (cursor_row_fully_visible_p (w, false, true, false))
 17060                 {
 17061 #ifdef GLYPH_DEBUG
 17062                   *w->desired_matrix->method = 0;
 17063                   debug_method_add (w, "optimization 3");
 17064 #endif
 17065                   goto update;
 17066                 }
 17067               else
 17068                 goto cancel;
 17069             }
 17070           else
 17071             goto cancel;
 17072         }
 17073 
 17074     cancel:
 17075       /* Text changed drastically or point moved off of line.  */
 17076       SET_MATRIX_ROW_ENABLED_P (w->desired_matrix, this_line_vpos, false);
 17077     }
 17078 
 17079   CHARPOS (this_line_start_pos) = 0;
 17080   ++clear_face_cache_count;
 17081 #ifdef HAVE_WINDOW_SYSTEM
 17082   ++clear_image_cache_count;
 17083 #endif
 17084 
 17085   /* Build desired matrices, and update the display.  If
 17086      consider_all_windows_p, do it for all windows on all frames that
 17087      require redisplay, as specified by their 'redisplay' flag.
 17088      Otherwise do it for selected_window, only.  */
 17089 
 17090   if (consider_all_windows_p)
 17091     {
 17092       FOR_EACH_FRAME (tail, frame)
 17093         XFRAME (frame)->updated_p = false;
 17094 
 17095       propagate_buffer_redisplay ();
 17096 
 17097       FOR_EACH_FRAME (tail, frame)
 17098         {
 17099           struct frame *f = XFRAME (frame);
 17100 
 17101           /* We don't have to do anything for unselected terminal
 17102              frames.  */
 17103           if ((FRAME_TERMCAP_P (f) || FRAME_MSDOS_P (f))
 17104               && !EQ (FRAME_TTY (f)->top_frame, frame))
 17105             continue;
 17106 
 17107         retry_frame:
 17108           if (FRAME_WINDOW_P (f) || FRAME_TERMCAP_P (f) || f == sf)
 17109             {
 17110               bool gcscrollbars
 17111                 /* Only GC scrollbars when we redisplay the whole frame.  */
 17112                 = f->redisplay || !REDISPLAY_SOME_P ();
 17113               bool f_redisplay_flag = f->redisplay;
 17114 
 17115               /* The X error handler may have deleted that frame
 17116                  before we went back to retry_frame.  This must come
 17117                  before any accesses to f->terminal.  */
 17118               if (!FRAME_LIVE_P (f))
 17119                 continue;
 17120 
 17121               /* Mark all the scroll bars to be removed; we'll redeem
 17122                  the ones we want when we redisplay their windows.  */
 17123               if (gcscrollbars && FRAME_TERMINAL (f)->condemn_scroll_bars_hook)
 17124                 FRAME_TERMINAL (f)->condemn_scroll_bars_hook (f);
 17125 
 17126               if (FRAME_REDISPLAY_P (f) && !FRAME_OBSCURED_P (f))
 17127                 {
 17128                   /* Don't allow freeing images and faces for this
 17129                      frame as long as the frame's update wasn't
 17130                      completed.  This prevents crashes when some Lisp
 17131                      that runs from the various hooks or font-lock
 17132                      decides to clear the frame's image cache and face
 17133                      cache, when the images and faces in those caches
 17134                      are referenced by the desired matrix.  */
 17135                   f->inhibit_clear_image_cache = true;
 17136                   redisplay_windows (FRAME_ROOT_WINDOW (f));
 17137                 }
 17138               /* Remember that the invisible frames need to be redisplayed next
 17139                  time they're visible.  */
 17140               else if (!REDISPLAY_SOME_P ())
 17141                 f->redisplay = true;
 17142 
 17143               /* The X error handler may have deleted that frame.  */
 17144               if (!FRAME_LIVE_P (f))
 17145                 continue;
 17146 
 17147               /* Any scroll bars which redisplay_windows should have
 17148                  nuked should now go away.  */
 17149               if (gcscrollbars && FRAME_TERMINAL (f)->judge_scroll_bars_hook)
 17150                 FRAME_TERMINAL (f)->judge_scroll_bars_hook (f);
 17151 
 17152               if (FRAME_REDISPLAY_P (f) && !FRAME_OBSCURED_P (f))
 17153                 {
 17154                   /* If fonts changed on visible frame, display again.  */
 17155                   if (f->fonts_changed)
 17156                     {
 17157                       adjust_frame_glyphs (f);
 17158                       /* Disable all redisplay optimizations for this
 17159                          frame.  For the reasons, see the comment near
 17160                          the previous call to adjust_frame_glyphs above.  */
 17161                       SET_FRAME_GARBAGED (f);
 17162                       f->fonts_changed = false;
 17163                       goto retry_frame;
 17164                     }
 17165 
 17166                   /* See if we have to hscroll.  */
 17167                   if (!f->already_hscrolled_p)
 17168                     {
 17169                       f->already_hscrolled_p = true;
 17170                       if (hscroll_retries <= MAX_HSCROLL_RETRIES
 17171                           && hscroll_windows (f->root_window))
 17172                         {
 17173                           hscroll_retries++;
 17174                           goto retry_frame;
 17175                         }
 17176                     }
 17177 
 17178                   /* If the frame's redisplay flag was not set before
 17179                      we went about redisplaying its windows, but it is
 17180                      set now, that means we employed some redisplay
 17181                      optimizations inside redisplay_windows, and
 17182                      bypassed producing some screen lines.  But if
 17183                      f->redisplay is now set, it might mean the old
 17184                      faces are no longer valid (e.g., if redisplaying
 17185                      some window called some Lisp which defined a new
 17186                      face or redefined an existing face), so trying to
 17187                      use them in update_frame will segfault.
 17188                      Therefore, we must redisplay this frame.  */
 17189                   if (!f_redisplay_flag && f->redisplay)
 17190                     goto retry_frame;
 17191                   /* In some case (e.g., window resize), we notice
 17192                      only during window updating that the window
 17193                      content changed unpredictably (e.g., a GTK
 17194                      scrollbar moved, or some Lisp hook that winds up
 17195                      calling adjust_frame_glyphs) and that our
 17196                      previous estimation of the frame content was
 17197                      garbage.  We have to start over.  These cases
 17198                      should be rare, so going all the way back to the
 17199                      top of redisplay should be good enough.  */
 17200                   if (FRAME_GARBAGED_P (f)
 17201                       && garbaged_frame_retries++ < MAX_GARBAGED_FRAME_RETRIES)
 17202                     goto retry;
 17203 
 17204 #ifdef HAVE_WINDOW_SYSTEM
 17205                   if (FRAME_WINDOW_P (f)
 17206                       && FRAME_RIF (f)->clear_under_internal_border)
 17207                     FRAME_RIF (f)->clear_under_internal_border (f);
 17208 #endif
 17209                   /* Prevent various kinds of signals during display
 17210                      update.  stdio is not robust about handling
 17211                      signals, which can cause an apparent I/O error.  */
 17212                   if (interrupt_input)
 17213                     unrequest_sigio ();
 17214                   STOP_POLLING;
 17215 
 17216                   pending |= update_frame (f, false, false);
 17217                   /* On some platforms (at least MS-Windows), the
 17218                      scroll_run_hook called from scrolling_window
 17219                      called from update_frame could set the frame's
 17220                      garbaged flag, in which case we need to redisplay
 17221                      the frame.  Don't do that on TTY frames, since we
 17222                      need to keep the garbaged flag in that case when
 17223                      the frame has been resized.  */
 17224                   if (FRAME_GARBAGED_P (f))
 17225                     {
 17226                       fset_redisplay (f);
 17227                       f->garbaged = false;
 17228                       goto retry_frame;
 17229                     }
 17230                   f->cursor_type_changed = false;
 17231                   f->updated_p = true;
 17232                   f->inhibit_clear_image_cache = false;
 17233                 }
 17234             }
 17235         }
 17236 
 17237       eassert (EQ (XFRAME (selected_frame)->selected_window, selected_window));
 17238 
 17239       if (!pending)
 17240         {
 17241           /* Do the mark_window_display_accurate after all windows have
 17242              been redisplayed because this call resets flags in buffers
 17243              which are needed for proper redisplay.  */
 17244           FOR_EACH_FRAME (tail, frame)
 17245             {
 17246               struct frame *f = XFRAME (frame);
 17247               if (f->updated_p)
 17248                 {
 17249                   f->redisplay = false;
 17250                   f->garbaged = false;
 17251                   mark_window_display_accurate (f->root_window, true);
 17252                   if (FRAME_TERMINAL (f)->frame_up_to_date_hook)
 17253                     FRAME_TERMINAL (f)->frame_up_to_date_hook (f);
 17254                 }
 17255             }
 17256         }
 17257     }
 17258   else if (FRAME_REDISPLAY_P (sf) && !FRAME_OBSCURED_P (sf))
 17259     {
 17260       sf->inhibit_clear_image_cache = true;
 17261       displayed_buffer = XBUFFER (XWINDOW (selected_window)->contents);
 17262       /* Use list_of_error, not Qerror, so that
 17263          we catch only errors and don't run the debugger.  */
 17264       internal_condition_case_1 (redisplay_window_1, selected_window,
 17265                                  list_of_error,
 17266                                  redisplay_window_error);
 17267       if (update_miniwindow_p)
 17268         {
 17269           Lisp_Object mini_window = FRAME_MINIBUF_WINDOW (sf);
 17270 
 17271           displayed_buffer = XBUFFER (XWINDOW (mini_window)->contents);
 17272           internal_condition_case_1 (redisplay_window_1, mini_window,
 17273                                      list_of_error,
 17274                                      redisplay_window_error);
 17275         }
 17276 
 17277       /* Compare desired and current matrices, perform output.  */
 17278 
 17279     update:
 17280       /* If fonts changed, display again.  Likewise if redisplay_window_1
 17281          above caused some change (e.g., a change in faces) that requires
 17282          considering the entire frame again.  */
 17283       if (sf->fonts_changed || sf->redisplay)
 17284         {
 17285           if (sf->redisplay)
 17286             {
 17287               /* Set this to force a more thorough redisplay.
 17288                  Otherwise, we might immediately loop back to the
 17289                  above "else-if" clause (since all the conditions that
 17290                  led here might still be true), and we will then
 17291                  infloop, because the selected-frame's redisplay flag
 17292                  is not (and cannot be) reset.  */
 17293               windows_or_buffers_changed = 50;
 17294             }
 17295           goto retry;
 17296         }
 17297 
 17298       /* Prevent freeing of realized faces, since desired matrices are
 17299          pending that reference the faces we computed and cached.  */
 17300       inhibit_free_realized_faces = true;
 17301 
 17302       /* Prevent various kinds of signals during display update.
 17303          stdio is not robust about handling signals,
 17304          which can cause an apparent I/O error.  */
 17305       if (interrupt_input)
 17306         unrequest_sigio ();
 17307       STOP_POLLING;
 17308 
 17309       if (FRAME_REDISPLAY_P (sf) && !FRAME_OBSCURED_P (sf))
 17310         {
 17311           if (hscroll_retries <= MAX_HSCROLL_RETRIES
 17312               && hscroll_windows (selected_window))
 17313             {
 17314               hscroll_retries++;
 17315               goto retry;
 17316             }
 17317 
 17318           XWINDOW (selected_window)->must_be_updated_p = true;
 17319           pending = update_frame (sf, false, false);
 17320           sf->cursor_type_changed = false;
 17321           sf->inhibit_clear_image_cache = false;
 17322         }
 17323 
 17324       /* We may have called echo_area_display at the top of this
 17325          function.  If the echo area is on another frame, that may
 17326          have put text on a frame other than the selected one, so the
 17327          above call to update_frame would not have caught it.  Catch
 17328          it here.  */
 17329       Lisp_Object mini_window = FRAME_MINIBUF_WINDOW (sf);
 17330       struct frame *mini_frame = XFRAME (WINDOW_FRAME (XWINDOW (mini_window)));
 17331 
 17332       if (mini_frame != sf && FRAME_WINDOW_P (mini_frame))
 17333         {
 17334           XWINDOW (mini_window)->must_be_updated_p = true;
 17335           pending |= update_frame (mini_frame, false, false);
 17336           mini_frame->cursor_type_changed = false;
 17337           if (!pending && hscroll_retries <= MAX_HSCROLL_RETRIES
 17338               && hscroll_windows (mini_window))
 17339             {
 17340               hscroll_retries++;
 17341               goto retry;
 17342             }
 17343         }
 17344     }
 17345 
 17346   /* If display was paused because of pending input, make sure we do a
 17347      thorough update the next time.  */
 17348   if (pending)
 17349     {
 17350       /* Prevent the optimization at the beginning of
 17351          redisplay_internal that tries a single-line update of the
 17352          line containing the cursor in the selected window.  */
 17353       CHARPOS (this_line_start_pos) = 0;
 17354 
 17355       /* Let the overlay arrow be updated the next time.  */
 17356       update_overlay_arrows (0);
 17357 
 17358       /* If we pause after scrolling, some rows in the current
 17359          matrices of some windows are not valid.  */
 17360       if (!WINDOW_FULL_WIDTH_P (w)
 17361           && !FRAME_WINDOW_P (XFRAME (w->frame)))
 17362         update_mode_lines = 36;
 17363     }
 17364   else
 17365     {
 17366       if (!consider_all_windows_p)
 17367         {
 17368           /* This has already been done above if
 17369              consider_all_windows_p is set.  */
 17370           if (XBUFFER (w->contents)->text->redisplay
 17371               && buffer_window_count (XBUFFER (w->contents)) > 1)
 17372             /* This can happen if b->text->redisplay was set during
 17373                jit-lock.  */
 17374             propagate_buffer_redisplay ();
 17375           mark_window_display_accurate_1 (w, true);
 17376 
 17377           /* Say overlay arrows are up to date.  */
 17378           update_overlay_arrows (1);
 17379 
 17380           if (FRAME_TERMINAL (sf)->frame_up_to_date_hook != 0)
 17381             FRAME_TERMINAL (sf)->frame_up_to_date_hook (sf);
 17382         }
 17383 
 17384       update_mode_lines = 0;
 17385       windows_or_buffers_changed = 0;
 17386     }
 17387 
 17388   /* Start SIGIO interrupts coming again.  Having them off during the
 17389      code above makes it less likely one will discard output, but not
 17390      impossible, since there might be stuff in the system buffer here.
 17391      But it is much hairier to try to do anything about that.  */
 17392   if (interrupt_input)
 17393     request_sigio ();
 17394   RESUME_POLLING;
 17395 
 17396   /* If a frame has become visible which was not before, redisplay
 17397      again, so that we display it.  Expose events for such a frame
 17398      (which it gets when becoming visible) don't call the parts of
 17399      redisplay constructing glyphs, so simply exposing a frame won't
 17400      display anything in this case.  So, we have to display these
 17401      frames here explicitly.  */
 17402   if (!pending)
 17403     {
 17404       int new_count = 0;
 17405 
 17406       FOR_EACH_FRAME (tail, frame)
 17407         {
 17408           if (FRAME_REDISPLAY_P (XFRAME (frame)))
 17409             new_count++;
 17410         }
 17411 
 17412       if (new_count != number_of_visible_frames)
 17413         windows_or_buffers_changed = 52;
 17414     }
 17415 
 17416   /* Change frame size now if a change is pending.  */
 17417   do_pending_window_change (true);
 17418 
 17419   /* If we just did a pending size change, or have additional
 17420      visible frames, or selected_window changed, redisplay again.  */
 17421   if ((windows_or_buffers_changed && !pending)
 17422       || (WINDOWP (selected_window)
 17423           && (w = XWINDOW (selected_window)) != sw))
 17424     goto retry;
 17425 
 17426   /* Clear the face and image caches.
 17427 
 17428      We used to do this only if consider_all_windows_p.  But the cache
 17429      needs to be cleared if a timer creates images in the current
 17430      buffer (e.g. the test case in Bug#6230).  */
 17431 
 17432   if (clear_face_cache_count > CLEAR_FACE_CACHE_COUNT)
 17433     {
 17434       clear_face_cache (false);
 17435       clear_face_cache_count = 0;
 17436     }
 17437 
 17438 #ifdef HAVE_WINDOW_SYSTEM
 17439   if (clear_image_cache_count > CLEAR_IMAGE_CACHE_COUNT)
 17440     {
 17441       clear_image_caches (Qnil);
 17442       clear_image_cache_count = 0;
 17443     }
 17444 #endif /* HAVE_WINDOW_SYSTEM */
 17445 
 17446  end_of_redisplay:
 17447 #ifdef HAVE_NS
 17448   ns_set_doc_edited ();
 17449 #endif
 17450   if (interrupt_input && interrupts_deferred)
 17451     request_sigio ();
 17452 
 17453   /* We're done with this redisplay cycle, so reset the tick count in
 17454      preparation for the next redisplay cycle.  */
 17455   if (max_redisplay_ticks > 0)
 17456     update_redisplay_ticks (0, NULL);
 17457 
 17458   unbind_to (count, Qnil);
 17459   RESUME_POLLING;
 17460 }
 17461 
 17462 static void
 17463 unwind_redisplay_preserve_echo_area (void)
 17464 {
 17465   unblock_buffer_flips ();
 17466 }
 17467 
 17468 /* Redisplay, but leave alone any recent echo area message unless
 17469    another message has been requested in its place.
 17470 
 17471    This is useful in situations where you need to redisplay but no
 17472    user action has occurred, making it inappropriate for the message
 17473    area to be cleared.  See tracking_off and
 17474    wait_reading_process_output for examples of these situations.
 17475 
 17476    FROM_WHERE is an integer saying from where this function was
 17477    called.  This is useful for debugging.  */
 17478 
 17479 void
 17480 redisplay_preserve_echo_area (int from_where)
 17481 {
 17482   redisplay_trace ("redisplay_preserve_echo_area (%d)\n", from_where);
 17483 
 17484   block_input ();
 17485   specpdl_ref count = SPECPDL_INDEX ();
 17486   record_unwind_protect_void (unwind_redisplay_preserve_echo_area);
 17487   block_buffer_flips ();
 17488   unblock_input ();
 17489 
 17490   if (!NILP (echo_area_buffer[1]))
 17491     {
 17492       /* We have a previously displayed message, but no current
 17493          message.  Redisplay the previous message.  */
 17494       display_last_displayed_message_p = true;
 17495       redisplay_internal ();
 17496       display_last_displayed_message_p = false;
 17497     }
 17498   else
 17499     redisplay_internal ();
 17500 
 17501   flush_frame (SELECTED_FRAME ());
 17502   unbind_to (count, Qnil);
 17503 }
 17504 
 17505 
 17506 /* Function registered with record_unwind_protect in redisplay_internal.  */
 17507 
 17508 static void
 17509 unwind_redisplay (void)
 17510 {
 17511   redisplaying_p = false;
 17512   unblock_buffer_flips ();
 17513 }
 17514 
 17515 /* Function registered with record_unwind_protect before calling
 17516    start_display outside of redisplay_internal.  */
 17517 void
 17518 unwind_display_working_on_window (void)
 17519 {
 17520   display_working_on_window_p = false;
 17521 }
 17522 
 17523 /* Mark the display of leaf window W as accurate or inaccurate.
 17524    If ACCURATE_P, mark display of W as accurate.
 17525    If !ACCURATE_P, arrange for W to be redisplayed the next
 17526    time redisplay_internal is called.  */
 17527 
 17528 static void
 17529 mark_window_display_accurate_1 (struct window *w, bool accurate_p)
 17530 {
 17531   struct buffer *b = XBUFFER (w->contents);
 17532 #ifdef HAVE_TEXT_CONVERSION
 17533   ptrdiff_t prev_point, prev_mark;
 17534 #endif /* HAVE_TEXT_CONVERSION */
 17535 
 17536   w->last_modified = accurate_p ? BUF_MODIFF (b) : 0;
 17537   w->last_overlay_modified = accurate_p ? BUF_OVERLAY_MODIFF (b) : 0;
 17538   w->last_had_star = BUF_MODIFF (b) > BUF_SAVE_MODIFF (b);
 17539 
 17540   if (accurate_p)
 17541     {
 17542       b->clip_changed = false;
 17543       b->prevent_redisplay_optimizations_p = false;
 17544       eassert (buffer_window_count (b) > 0);
 17545       /* Resetting b->text->redisplay is problematic!
 17546          In order to make it safer to do it here, redisplay_internal must
 17547          have copied all b->text->redisplay to their respective windows.  */
 17548       b->text->redisplay = false;
 17549 
 17550       BUF_UNCHANGED_MODIFIED (b) = BUF_MODIFF (b);
 17551       BUF_OVERLAY_UNCHANGED_MODIFIED (b) = BUF_OVERLAY_MODIFF (b);
 17552       BUF_BEG_UNCHANGED (b) = BUF_GPT (b) - BUF_BEG (b);
 17553       BUF_END_UNCHANGED (b) = BUF_Z (b) - BUF_GPT (b);
 17554 
 17555       w->current_matrix->buffer = b;
 17556       w->current_matrix->begv = BUF_BEGV (b);
 17557       w->current_matrix->zv = BUF_ZV (b);
 17558       w->current_matrix->header_line_p = window_wants_header_line (w);
 17559       w->current_matrix->tab_line_p = window_wants_tab_line (w);
 17560 
 17561       w->last_cursor_vpos = w->cursor.vpos;
 17562       w->last_cursor_off_p = w->cursor_off_p;
 17563 
 17564 #ifdef HAVE_TEXT_CONVERSION
 17565       prev_point = w->last_point;
 17566       prev_mark = w->last_mark;
 17567 #endif /* HAVE_TEXT_CONVERSION */
 17568 
 17569       if (w == XWINDOW (selected_window))
 17570         w->last_point = BUF_PT (b);
 17571       else
 17572         w->last_point = marker_position (w->pointm);
 17573 
 17574       /* w->last_mark is recorded for text conversion purposes.
 17575          Input methods aren't interested in the value of the mark
 17576          if it is inactive, so set it to -1 if it's not.  */
 17577 
 17578       if (XMARKER (BVAR (b, mark))->buffer == b
 17579           && !NILP (BVAR (b, mark_active)))
 17580         w->last_mark = marker_position (BVAR (b, mark));
 17581       else
 17582         w->last_mark = -1;
 17583 
 17584 #ifdef HAVE_TEXT_CONVERSION
 17585       /* See the description of this field in struct window.  */
 17586       w->ephemeral_last_point = w->last_point;
 17587 
 17588       /* Point motion is only propagated to the input method for use
 17589          in text conversion during a redisplay.  While this can lead
 17590          to inconsistencies when point has moved but the change has
 17591          not yet been displayed, it leads to better results most of
 17592          the time, as point often changes within calls to
 17593          `save-excursion', and the only way to detect such calls is to
 17594          observe that the next redisplay never ends with those changes
 17595          applied.
 17596 
 17597          Changes to buffer text are immediately propagated to the
 17598          input method, and the position of point is also updated
 17599          during such a change, so the consequences are not that
 17600          severe.  */
 17601 
 17602       if ((prev_point != w->last_point
 17603            || prev_mark != w->last_mark)
 17604           && FRAME_WINDOW_P (WINDOW_XFRAME (w))
 17605           && w == XWINDOW (WINDOW_XFRAME (w)->selected_window))
 17606         report_point_change (WINDOW_XFRAME (w), w, b);
 17607 #endif /* HAVE_TEXT_CONVERSION */
 17608 
 17609       w->window_end_valid = true;
 17610       w->update_mode_line = false;
 17611       w->preserve_vscroll_p = false;
 17612     }
 17613 
 17614   w->redisplay = !accurate_p;
 17615 }
 17616 
 17617 
 17618 /* Mark the display of windows in the window tree rooted at WINDOW as
 17619    accurate or inaccurate.  If ACCURATE_P, mark display of
 17620    windows as accurate.  If !ACCURATE_P, arrange for windows to
 17621    be redisplayed the next time redisplay_internal is called.  */
 17622 
 17623 void
 17624 mark_window_display_accurate (Lisp_Object window, bool accurate_p)
 17625 {
 17626   struct window *w;
 17627 
 17628   for (; !NILP (window); window = w->next)
 17629     {
 17630       w = XWINDOW (window);
 17631       if (WINDOWP (w->contents))
 17632         mark_window_display_accurate (w->contents, accurate_p);
 17633       else
 17634         mark_window_display_accurate_1 (w, accurate_p);
 17635     }
 17636 
 17637   if (accurate_p)
 17638     update_overlay_arrows (1);
 17639   else
 17640     /* Force a thorough redisplay the next time by setting
 17641        last_arrow_position and last_arrow_string to t, which is
 17642        unequal to any useful value of Voverlay_arrow_...  */
 17643     update_overlay_arrows (-1);
 17644 }
 17645 
 17646 
 17647 /* Return value in display table DP (Lisp_Char_Table *) for character
 17648    C.  Since a display table doesn't have any parent, we don't have to
 17649    follow parent.  Do not call this function directly but use the
 17650    macro DISP_CHAR_VECTOR.  */
 17651 
 17652 Lisp_Object
 17653 disp_char_vector (struct Lisp_Char_Table *dp, int c)
 17654 {
 17655   Lisp_Object val;
 17656 
 17657   if (ASCII_CHAR_P (c))
 17658     {
 17659       val = dp->ascii;
 17660       if (SUB_CHAR_TABLE_P (val))
 17661         val = XSUB_CHAR_TABLE (val)->contents[c];
 17662     }
 17663   else
 17664     {
 17665       Lisp_Object table;
 17666 
 17667       XSETCHAR_TABLE (table, dp);
 17668       val = char_table_ref (table, c);
 17669     }
 17670   if (NILP (val))
 17671     val = dp->defalt;
 17672   return val;
 17673 }
 17674 
 17675 static int buffer_flip_blocked_depth;
 17676 
 17677 static void
 17678 block_buffer_flips (void)
 17679 {
 17680   eassert (buffer_flip_blocked_depth >= 0);
 17681   buffer_flip_blocked_depth++;
 17682 }
 17683 
 17684 static void
 17685 unblock_buffer_flips (void)
 17686 {
 17687   eassert (buffer_flip_blocked_depth > 0);
 17688   if (--buffer_flip_blocked_depth == 0)
 17689     {
 17690       Lisp_Object tail, frame;
 17691       block_input ();
 17692       FOR_EACH_FRAME (tail, frame)
 17693         {
 17694           struct frame *f = XFRAME (frame);
 17695           if (FRAME_TERMINAL (f)->buffer_flipping_unblocked_hook)
 17696             (*FRAME_TERMINAL (f)->buffer_flipping_unblocked_hook) (f);
 17697         }
 17698       unblock_input ();
 17699     }
 17700 }
 17701 
 17702 bool
 17703 buffer_flipping_blocked_p (void)
 17704 {
 17705   return buffer_flip_blocked_depth > 0;
 17706 }
 17707 
 17708 
 17709 /***********************************************************************
 17710                            Window Redisplay
 17711  ***********************************************************************/
 17712 
 17713 /* Redisplay all leaf windows in the window tree rooted at WINDOW.  */
 17714 
 17715 static void
 17716 redisplay_windows (Lisp_Object window)
 17717 {
 17718   while (!NILP (window))
 17719     {
 17720       struct window *w = XWINDOW (window);
 17721 
 17722       if (WINDOWP (w->contents))
 17723         redisplay_windows (w->contents);
 17724       else if (BUFFERP (w->contents))
 17725         {
 17726           displayed_buffer = XBUFFER (w->contents);
 17727           /* Use list_of_error, not Qerror, so that
 17728              we catch only errors and don't run the debugger.  */
 17729           internal_condition_case_1 (redisplay_window_0, window,
 17730                                      list_of_error,
 17731                                      redisplay_window_error);
 17732         }
 17733 
 17734       window = w->next;
 17735     }
 17736 }
 17737 
 17738 static Lisp_Object
 17739 redisplay_window_error (Lisp_Object error_data)
 17740 {
 17741   displayed_buffer->display_error_modiff = BUF_MODIFF (displayed_buffer);
 17742 
 17743   /* When in redisplay, the error is captured and not shown.  Arrange
 17744      for it to be shown later.  */
 17745   if (max_redisplay_ticks > 0
 17746       && CONSP (error_data)
 17747       && EQ (XCAR (error_data), Qerror)
 17748       && STRINGP (XCAR (XCDR (error_data))))
 17749     Vdelayed_warnings_list = Fcons (list2 (XCAR (error_data),
 17750                                            XCAR (XCDR (error_data))),
 17751                                     Vdelayed_warnings_list);
 17752   return Qnil;
 17753 }
 17754 
 17755 static Lisp_Object
 17756 redisplay_window_0 (Lisp_Object window)
 17757 {
 17758   if (displayed_buffer->display_error_modiff < BUF_MODIFF (displayed_buffer))
 17759     redisplay_window (window, false);
 17760   return Qnil;
 17761 }
 17762 
 17763 static Lisp_Object
 17764 redisplay_window_1 (Lisp_Object window)
 17765 {
 17766   if (displayed_buffer->display_error_modiff < BUF_MODIFF (displayed_buffer))
 17767     redisplay_window (window, true);
 17768   return Qnil;
 17769 }
 17770 
 17771 
 17772 /***********************************************************************
 17773                       Aborting runaway redisplay
 17774  ***********************************************************************/
 17775 
 17776 /* Update the redisplay-tick count for window W, and signal an error
 17777    if the tick count is above some threshold, indicating that
 17778    redisplay of the window takes "too long".
 17779 
 17780    TICKS is the amount of ticks to add to the W's current count; zero
 17781    means to initialize the tick count to zero.
 17782 
 17783    W can be NULL if TICKS is zero: that means unconditionally
 17784    re-initialize the current tick count to zero.
 17785 
 17786    W can also be NULL if the caller doesn't know which window is being
 17787    processed by the display code.  In that case, if TICKS is non-zero,
 17788    we assume it's the last window that shows the current buffer.  */
 17789 void
 17790 update_redisplay_ticks (int ticks, struct window *w)
 17791 {
 17792   /* This keeps track of the window on which redisplay is working.  */
 17793   static struct window *cwindow;
 17794   static EMACS_INT window_ticks;
 17795 
 17796   /* We only initialize the count if this is a different window or
 17797      NULL.  Otherwise, this is a call from init_iterator for the same
 17798      window we tracked before, and we should keep the count.  */
 17799   if (!ticks && w != cwindow)
 17800     {
 17801       cwindow = w;
 17802       window_ticks = 0;
 17803     }
 17804   /* Some callers can be run in contexts unrelated to display code, so
 17805      don't abort them and don't update the tick count in those cases.  */
 17806   if ((!w && !redisplaying_p && !display_working_on_window_p)
 17807       /* We never disable redisplay of a mini-window, since that is
 17808          absolutely essential for communicating with Emacs.  */
 17809       || (w && MINI_WINDOW_P (w)))
 17810     return;
 17811 
 17812   if (ticks > 0)
 17813     window_ticks += ticks;
 17814   if (max_redisplay_ticks > 0 && window_ticks > max_redisplay_ticks)
 17815     {
 17816       /* In addition to a buffer, this could be a window (for non-leaf
 17817          windows, not expected here) or nil (for pseudo-windows like
 17818          the one used for the native tool bar).  */
 17819       Lisp_Object contents = w ? w->contents : Qnil;
 17820       char *bufname =
 17821         NILP (contents)
 17822         ? SSDATA (BVAR (current_buffer, name))
 17823         : (BUFFERP (contents)
 17824            ? SSDATA (BVAR (XBUFFER (contents), name))
 17825            : (char *) "<unknown>");
 17826 
 17827       windows_or_buffers_changed = 177;
 17828       /* scrolling_window depends too much on the glyph matrices being
 17829          correct, and we cannot guarantee that if we abort the
 17830          redisplay of this window.  */
 17831       if (w && w->desired_matrix)
 17832         w->desired_matrix->no_scrolling_p = true;
 17833       error ("Window showing buffer %s takes too long to redisplay", bufname);
 17834     }
 17835 }
 17836 
 17837 
 17838 
 17839 /* Set cursor position of W.  PT is assumed to be displayed in ROW.
 17840    DELTA and DELTA_BYTES are the numbers of characters and bytes by
 17841    which positions recorded in ROW differ from current buffer
 17842    positions.
 17843 
 17844    Return true iff cursor is on this row.  */
 17845 
 17846 static bool
 17847 set_cursor_from_row (struct window *w, struct glyph_row *row,
 17848                      struct glyph_matrix *matrix,
 17849                      ptrdiff_t delta, ptrdiff_t delta_bytes,
 17850                      int dy, int dvpos)
 17851 {
 17852   struct glyph *glyph = row->glyphs[TEXT_AREA];
 17853   struct glyph *end = glyph + row->used[TEXT_AREA];
 17854   struct glyph *cursor = NULL;
 17855   /* The last known character position in row.  */
 17856   ptrdiff_t last_pos = MATRIX_ROW_START_CHARPOS (row) + delta;
 17857   int x = row->x;
 17858   ptrdiff_t pt_old = PT - delta;
 17859   ptrdiff_t pos_before = MATRIX_ROW_START_CHARPOS (row) + delta;
 17860   ptrdiff_t pos_after = MATRIX_ROW_END_CHARPOS (row) + delta;
 17861   struct glyph *glyph_before = glyph - 1, *glyph_after = end;
 17862   /* A glyph beyond the edge of TEXT_AREA which we should never
 17863      touch.  */
 17864   struct glyph *glyphs_end = end;
 17865   /* True means we've found a match for cursor position, but that
 17866      glyph has the avoid_cursor_p flag set.  */
 17867   bool match_with_avoid_cursor = false;
 17868   /* True means we've seen at least one glyph that came from a
 17869      display string.  */
 17870   bool string_seen = false;
 17871   /* Largest and smallest buffer positions seen so far during scan of
 17872      glyph row.  */
 17873   ptrdiff_t bpos_max = pos_before;
 17874   ptrdiff_t bpos_min = pos_after;
 17875   /* Last buffer position covered by an overlay string with an integer
 17876      `cursor' property.  */
 17877   ptrdiff_t bpos_covered = 0;
 17878   /* True means the display string on which to display the cursor
 17879      comes from a text property, not from an overlay.  */
 17880   bool string_from_text_prop = false;
 17881 
 17882   /* Don't even try doing anything if called for a mode-line or
 17883      header-line or tab-line row, since the rest of the code isn't
 17884      prepared to deal with such calamities.  */
 17885   eassert (!row->mode_line_p);
 17886   if (row->mode_line_p)
 17887     return false;
 17888 
 17889   /* Skip over glyphs not having an object at the start and the end of
 17890      the row.  These are special glyphs like truncation marks on
 17891      terminal frames.  */
 17892   if (MATRIX_ROW_DISPLAYS_TEXT_P (row))
 17893     {
 17894       if (!row->reversed_p)
 17895         {
 17896           while (glyph < end
 17897                  && NILP (glyph->object)
 17898                  && glyph->charpos < 0)
 17899             {
 17900               x += glyph->pixel_width;
 17901               ++glyph;
 17902             }
 17903           while (end > glyph
 17904                  && NILP ((end - 1)->object)
 17905                  /* CHARPOS is zero for blanks and stretch glyphs
 17906                     inserted by extend_face_to_end_of_line.  */
 17907                  && (end - 1)->charpos <= 0)
 17908             --end;
 17909           glyph_before = glyph - 1;
 17910           glyph_after = end;
 17911         }
 17912       else
 17913         {
 17914           struct glyph *g;
 17915 
 17916           /* If the glyph row is reversed, we need to process it from back
 17917              to front, so swap the edge pointers.  */
 17918           glyphs_end = end = glyph - 1;
 17919           glyph += row->used[TEXT_AREA] - 1;
 17920 
 17921           while (glyph > end + 1
 17922                  && NILP (glyph->object)
 17923                  && glyph->charpos < 0)
 17924             --glyph;
 17925           if (NILP (glyph->object) && glyph->charpos < 0)
 17926             --glyph;
 17927           /* By default, in reversed rows we put the cursor on the
 17928              rightmost (first in the reading order) glyph.  */
 17929           for (x = 0, g = end + 1; g < glyph; g++)
 17930             x += g->pixel_width;
 17931           while (end < glyph
 17932                  && NILP ((end + 1)->object)
 17933                  && (end + 1)->charpos <= 0)
 17934             ++end;
 17935           glyph_before = glyph + 1;
 17936           glyph_after = end;
 17937         }
 17938     }
 17939   else if (row->reversed_p)
 17940     {
 17941       /* In R2L rows that don't display text, put the cursor on the
 17942          rightmost glyph.  Case in point: an empty last line that is
 17943          part of an R2L paragraph.  */
 17944       cursor = end - 1;
 17945       /* Avoid placing the cursor on the last glyph of the row, where
 17946          on terminal frames we hold the vertical border between
 17947          adjacent windows.  */
 17948       if (!FRAME_WINDOW_P (WINDOW_XFRAME (w))
 17949           && !WINDOW_RIGHTMOST_P (w)
 17950           && cursor == row->glyphs[LAST_AREA] - 1)
 17951         cursor--;
 17952       x = -1;   /* will be computed below, at label compute_x */
 17953     }
 17954 
 17955   /* Step 1: Try to find the glyph whose character position
 17956      corresponds to point.  If that's not possible, find 2 glyphs
 17957      whose character positions are the closest to point, one before
 17958      point, the other after it.  */
 17959   if (!row->reversed_p)
 17960     while (/* not marched to end of glyph row */
 17961            glyph < end
 17962            /* glyph was not inserted by redisplay for internal purposes */
 17963            && !NILP (glyph->object))
 17964       {
 17965         if (BUFFERP (glyph->object))
 17966           {
 17967             ptrdiff_t dpos = glyph->charpos - pt_old;
 17968 
 17969             if (glyph->charpos > bpos_max)
 17970               bpos_max = glyph->charpos;
 17971             if (glyph->charpos < bpos_min)
 17972               bpos_min = glyph->charpos;
 17973             if (!glyph->avoid_cursor_p)
 17974               {
 17975                 /* If we hit point, we've found the glyph on which to
 17976                    display the cursor.  */
 17977                 if (dpos == 0)
 17978                   {
 17979                     match_with_avoid_cursor = false;
 17980                     break;
 17981                   }
 17982                 /* See if we've found a better approximation to
 17983                    POS_BEFORE or to POS_AFTER.  */
 17984                 if (0 > dpos && dpos > pos_before - pt_old)
 17985                   {
 17986                     pos_before = glyph->charpos;
 17987                     glyph_before = glyph;
 17988                   }
 17989                 else if (0 < dpos && dpos < pos_after - pt_old)
 17990                   {
 17991                     pos_after = glyph->charpos;
 17992                     glyph_after = glyph;
 17993                   }
 17994               }
 17995             else if (dpos == 0)
 17996               match_with_avoid_cursor = true;
 17997           }
 17998         else if (STRINGP (glyph->object))
 17999           {
 18000             Lisp_Object chprop;
 18001             ptrdiff_t glyph_pos = glyph->charpos;
 18002 
 18003             chprop = Fget_char_property (make_fixnum (glyph_pos), Qcursor,
 18004                                          glyph->object);
 18005             if (!NILP (chprop))
 18006               {
 18007                 /* If the string came from a `display' text property,
 18008                    look up the buffer position of that property and
 18009                    use that position to update bpos_max, as if we
 18010                    actually saw such a position in one of the row's
 18011                    glyphs.  This helps with supporting integer values
 18012                    of `cursor' property on the display string in
 18013                    situations where most or all of the row's buffer
 18014                    text is completely covered by display properties,
 18015                    so that no glyph with valid buffer positions is
 18016                    ever seen in the row.  */
 18017                 ptrdiff_t prop_pos =
 18018                   string_buffer_position_lim (glyph->object, pos_before,
 18019                                               pos_after, false);
 18020 
 18021                 if (prop_pos >= pos_before)
 18022                   bpos_max = prop_pos;
 18023               }
 18024             if (FIXNUMP (chprop))
 18025               {
 18026                 bpos_covered = bpos_max + XFIXNUM (chprop);
 18027                 /* If the `cursor' property covers buffer positions up
 18028                    to and including point, we should display cursor on
 18029                    this glyph.  Note that, if a `cursor' property on one
 18030                    of the string's characters has an integer value, we
 18031                    will break out of the loop below _before_ we get to
 18032                    the position match above.  IOW, integer values of
 18033                    the `cursor' property override the "exact match for
 18034                    point" strategy of positioning the cursor.  */
 18035                 /* Implementation note: bpos_max == pt_old when, e.g.,
 18036                    we are in an empty line, where bpos_max is set to
 18037                    MATRIX_ROW_START_CHARPOS, see above.  */
 18038                 if (bpos_max <= pt_old && bpos_covered >= pt_old)
 18039                   {
 18040                     cursor = glyph;
 18041                     break;
 18042                   }
 18043               }
 18044 
 18045             string_seen = true;
 18046           }
 18047         x += glyph->pixel_width;
 18048         ++glyph;
 18049       }
 18050   else if (glyph > end) /* row is reversed */
 18051     while (!NILP (glyph->object))
 18052       {
 18053         if (BUFFERP (glyph->object))
 18054           {
 18055             ptrdiff_t dpos = glyph->charpos - pt_old;
 18056 
 18057             if (glyph->charpos > bpos_max)
 18058               bpos_max = glyph->charpos;
 18059             if (glyph->charpos < bpos_min)
 18060               bpos_min = glyph->charpos;
 18061             if (!glyph->avoid_cursor_p)
 18062               {
 18063                 if (dpos == 0)
 18064                   {
 18065                     match_with_avoid_cursor = false;
 18066                     break;
 18067                   }
 18068                 if (0 > dpos && dpos > pos_before - pt_old)
 18069                   {
 18070                     pos_before = glyph->charpos;
 18071                     glyph_before = glyph;
 18072                   }
 18073                 else if (0 < dpos && dpos < pos_after - pt_old)
 18074                   {
 18075                     pos_after = glyph->charpos;
 18076                     glyph_after = glyph;
 18077                   }
 18078               }
 18079             else if (dpos == 0)
 18080               match_with_avoid_cursor = true;
 18081           }
 18082         else if (STRINGP (glyph->object))
 18083           {
 18084             Lisp_Object chprop;
 18085             ptrdiff_t glyph_pos = glyph->charpos;
 18086 
 18087             chprop = Fget_char_property (make_fixnum (glyph_pos), Qcursor,
 18088                                          glyph->object);
 18089             if (!NILP (chprop))
 18090               {
 18091                 ptrdiff_t prop_pos =
 18092                   string_buffer_position_lim (glyph->object, pos_before,
 18093                                               pos_after, false);
 18094 
 18095                 if (prop_pos >= pos_before)
 18096                   bpos_max = prop_pos;
 18097               }
 18098             if (FIXNUMP (chprop))
 18099               {
 18100                 bpos_covered = bpos_max + XFIXNUM (chprop);
 18101                 /* If the `cursor' property covers buffer positions up
 18102                    to and including point, we should display cursor on
 18103                    this glyph.  */
 18104                 if (bpos_max <= pt_old && bpos_covered >= pt_old)
 18105                   {
 18106                     cursor = glyph;
 18107                     break;
 18108                   }
 18109               }
 18110             string_seen = true;
 18111           }
 18112         --glyph;
 18113         if (glyph == glyphs_end) /* don't dereference outside TEXT_AREA */
 18114           {
 18115             x--;                /* can't use any pixel_width */
 18116             break;
 18117           }
 18118         x -= glyph->pixel_width;
 18119     }
 18120 
 18121   /* Step 2: If we didn't find an exact match for point, we need to
 18122      look for a proper place to put the cursor among glyphs between
 18123      GLYPH_BEFORE and GLYPH_AFTER.  */
 18124   if (!((row->reversed_p ? glyph > glyphs_end : glyph < glyphs_end)
 18125         && BUFFERP (glyph->object) && glyph->charpos == pt_old)
 18126       && !(bpos_max <= pt_old && pt_old <= bpos_covered))
 18127     {
 18128       /* An empty line has a single glyph whose OBJECT is nil and
 18129          whose CHARPOS is the position of a newline on that line.
 18130          Note that on a TTY, there are more glyphs after that, which
 18131          were produced by extend_face_to_end_of_line, but their
 18132          CHARPOS is zero or negative.  */
 18133       bool empty_line_p =
 18134         ((row->reversed_p ? glyph > glyphs_end : glyph < glyphs_end)
 18135          && NILP (glyph->object) && glyph->charpos > 0
 18136          /* On a TTY, continued and truncated rows also have a glyph at
 18137             their end whose OBJECT is nil and whose CHARPOS is
 18138             positive (the continuation and truncation glyphs), but such
 18139             rows are obviously not "empty".  */
 18140          && !(row->continued_p || row->truncated_on_right_p));
 18141 
 18142       if (row->ends_in_ellipsis_p && pos_after == last_pos)
 18143         {
 18144           ptrdiff_t ellipsis_pos;
 18145 
 18146           /* Scan back over the ellipsis glyphs.  */
 18147           if (!row->reversed_p)
 18148             {
 18149               ellipsis_pos = (glyph - 1)->charpos;
 18150               while (glyph > row->glyphs[TEXT_AREA]
 18151                      && (glyph - 1)->charpos == ellipsis_pos)
 18152                 glyph--, x -= glyph->pixel_width;
 18153               /* That loop always goes one position too far, including
 18154                  the glyph before the ellipsis.  So scan forward over
 18155                  that one.  */
 18156               x += glyph->pixel_width;
 18157               glyph++;
 18158             }
 18159           else  /* row is reversed */
 18160             {
 18161               ellipsis_pos = (glyph + 1)->charpos;
 18162               while (glyph < row->glyphs[TEXT_AREA] + row->used[TEXT_AREA] - 1
 18163                      && (glyph + 1)->charpos == ellipsis_pos)
 18164                 glyph++, x += glyph->pixel_width;
 18165               x -= glyph->pixel_width;
 18166               glyph--;
 18167             }
 18168         }
 18169       else if (match_with_avoid_cursor)
 18170         {
 18171           cursor = glyph_after;
 18172           x = -1;
 18173         }
 18174       else if (string_seen)
 18175         {
 18176           int incr = row->reversed_p ? -1 : +1;
 18177 
 18178           /* Need to find the glyph that came out of a string which is
 18179              present at point.  That glyph is somewhere between
 18180              GLYPH_BEFORE and GLYPH_AFTER, and it came from a string
 18181              positioned between POS_BEFORE and POS_AFTER in the
 18182              buffer.  */
 18183           struct glyph *start, *stop;
 18184           ptrdiff_t pos = pos_before;
 18185 
 18186           x = -1;
 18187 
 18188           /* If the row ends in a newline from a display string,
 18189              reordering could have moved the glyphs belonging to the
 18190              string out of the [GLYPH_BEFORE..GLYPH_AFTER] range.  So
 18191              in this case we extend the search to the last glyph in
 18192              the row that was not inserted by redisplay.  */
 18193           if (row->ends_in_newline_from_string_p)
 18194             {
 18195               glyph_after = end;
 18196               pos_after = MATRIX_ROW_END_CHARPOS (row) + delta;
 18197             }
 18198 
 18199           /* GLYPH_BEFORE and GLYPH_AFTER are the glyphs that
 18200              correspond to POS_BEFORE and POS_AFTER, respectively.  We
 18201              need START and STOP in the order that corresponds to the
 18202              row's direction as given by its reversed_p flag.  If the
 18203              directionality of characters between POS_BEFORE and
 18204              POS_AFTER is the opposite of the row's base direction,
 18205              these characters will have been reordered for display,
 18206              and we need to reverse START and STOP.  */
 18207           if (!row->reversed_p)
 18208             {
 18209               start = min (glyph_before, glyph_after);
 18210               stop = max (glyph_before, glyph_after);
 18211             }
 18212           else
 18213             {
 18214               start = max (glyph_before, glyph_after);
 18215               stop = min (glyph_before, glyph_after);
 18216             }
 18217           for (glyph = start + incr;
 18218                row->reversed_p ? glyph > stop : glyph < stop; )
 18219             {
 18220 
 18221               /* Any glyphs that come from the buffer are here because
 18222                  of bidi reordering.  Skip them, and only pay
 18223                  attention to glyphs that came from some string.  */
 18224               if (STRINGP (glyph->object))
 18225                 {
 18226                   Lisp_Object str;
 18227                   ptrdiff_t tem;
 18228                   /* If the display property covers the newline, we
 18229                      need to search for it one position farther.  */
 18230                   ptrdiff_t lim = pos_after
 18231                     + (pos_after == MATRIX_ROW_END_CHARPOS (row) + delta);
 18232 
 18233                   string_from_text_prop = false;
 18234                   str = glyph->object;
 18235                   tem = string_buffer_position_lim (str, pos, lim, false);
 18236                   if (tem == 0  /* from overlay */
 18237                       || pos <= tem)
 18238                     {
 18239                       /* If the string from which this glyph came is
 18240                          found in the buffer at point, or at position
 18241                          that is closer to point than pos_after, then
 18242                          we've found the glyph we've been looking for.
 18243                          If it comes from an overlay (tem == 0), and
 18244                          it has the `cursor' property on one of its
 18245                          glyphs, record that glyph as a candidate for
 18246                          displaying the cursor.  (As in the
 18247                          unidirectional version, we will display the
 18248                          cursor on the last candidate we find.)  */
 18249                       if (tem == 0
 18250                           || tem == pt_old
 18251                           || (tem - pt_old > 0 && tem < pos_after))
 18252                         {
 18253                           /* The glyphs from this string could have
 18254                              been reordered.  Find the one with the
 18255                              smallest string position.  Or there could
 18256                              be a character in the string with the
 18257                              `cursor' property, which means display
 18258                              cursor on that character's glyph.  */
 18259                           ptrdiff_t strpos = glyph->charpos;
 18260 
 18261                           if (tem)
 18262                             {
 18263                               cursor = glyph;
 18264                               string_from_text_prop = true;
 18265                             }
 18266                           for ( ;
 18267                                (row->reversed_p ? glyph > stop : glyph < stop)
 18268                                  && EQ (glyph->object, str);
 18269                                glyph += incr)
 18270                             {
 18271                               Lisp_Object cprop;
 18272                               ptrdiff_t gpos = glyph->charpos;
 18273 
 18274                               cprop = Fget_char_property (make_fixnum (gpos),
 18275                                                           Qcursor,
 18276                                                           glyph->object);
 18277                               if (!NILP (cprop))
 18278                                 {
 18279                                   cursor = glyph;
 18280                                   break;
 18281                                 }
 18282                               if (tem && glyph->charpos < strpos)
 18283                                 {
 18284                                   strpos = glyph->charpos;
 18285                                   cursor = glyph;
 18286                                 }
 18287                             }
 18288 
 18289                           if (tem == pt_old
 18290                               || (tem - pt_old > 0 && tem < pos_after))
 18291                             goto compute_x;
 18292                         }
 18293                       if (tem)
 18294                         pos = tem + 1; /* don't find previous instances */
 18295                     }
 18296                   /* This string is not what we want; skip all of the
 18297                      glyphs that came from it.  */
 18298                   while ((row->reversed_p ? glyph > stop : glyph < stop)
 18299                          && EQ (glyph->object, str))
 18300                     glyph += incr;
 18301                 }
 18302               else
 18303                 glyph += incr;
 18304             }
 18305 
 18306           /* If we reached the end of the line, and END was from a string,
 18307              the cursor is not on this line.  */
 18308           if (cursor == NULL
 18309               && (row->reversed_p ? glyph <= end : glyph >= end)
 18310               && (row->reversed_p ? end > glyphs_end : end < glyphs_end)
 18311               && STRINGP (end->object)
 18312               && row->continued_p)
 18313             return false;
 18314         }
 18315       /* A truncated row may not include PT among its character positions.
 18316          Setting the cursor inside the scroll margin will trigger
 18317          recalculation of hscroll in hscroll_window_tree.  But if a
 18318          display string covers point, defer to the string-handling
 18319          code below to figure this out.  */
 18320       else if (row->truncated_on_left_p && pt_old < bpos_min)
 18321         {
 18322           cursor = glyph_before;
 18323           x = -1;
 18324         }
 18325       else if ((row->truncated_on_right_p && pt_old > bpos_max)
 18326                /* Zero-width characters produce no glyphs.  */
 18327                || (!empty_line_p
 18328                    && (row->reversed_p
 18329                        ? glyph_after > glyphs_end
 18330                        : glyph_after < glyphs_end)))
 18331         {
 18332           cursor = glyph_after;
 18333           x = -1;
 18334         }
 18335     }
 18336 
 18337  compute_x:
 18338   if (cursor != NULL)
 18339     glyph = cursor;
 18340   else if (glyph == glyphs_end
 18341            && pos_before == pos_after
 18342            && STRINGP ((row->reversed_p
 18343                         ? row->glyphs[TEXT_AREA] + row->used[TEXT_AREA] - 1
 18344                         : row->glyphs[TEXT_AREA])->object))
 18345     {
 18346       /* If all the glyphs of this row came from strings, put the
 18347          cursor on the first glyph of the row.  This avoids having the
 18348          cursor outside of the text area in this very rare and hard
 18349          use case.  */
 18350       glyph =
 18351         row->reversed_p
 18352         ? row->glyphs[TEXT_AREA] + row->used[TEXT_AREA] - 1
 18353         : row->glyphs[TEXT_AREA];
 18354     }
 18355   if (x < 0)
 18356     {
 18357       struct glyph *g;
 18358 
 18359       /* Need to compute x that corresponds to GLYPH.  */
 18360       for (g = row->glyphs[TEXT_AREA], x = row->x; g < glyph; g++)
 18361         {
 18362           if (g >= row->glyphs[TEXT_AREA] + row->used[TEXT_AREA])
 18363             emacs_abort ();
 18364           x += g->pixel_width;
 18365         }
 18366     }
 18367 
 18368   /* ROW could be part of a continued line, which, under bidi
 18369      reordering, might have other rows whose start and end charpos
 18370      occlude point.  Only set w->cursor if we found a better
 18371      approximation to the cursor position than we have from previously
 18372      examined candidate rows belonging to the same continued line.  */
 18373   if (/* We already have a candidate row.  */
 18374       w->cursor.vpos >= 0
 18375       /* That candidate is not the row we are processing.  */
 18376       && MATRIX_ROW (matrix, w->cursor.vpos) != row
 18377       /* Make sure cursor.vpos specifies a row whose start and end
 18378          charpos occlude point, and it is valid candidate for being a
 18379          cursor-row.  This is because some callers of this function
 18380          leave cursor.vpos at the row where the cursor was displayed
 18381          during the last redisplay cycle.  */
 18382       && MATRIX_ROW_START_CHARPOS (MATRIX_ROW (matrix, w->cursor.vpos)) <= pt_old
 18383       && pt_old <= MATRIX_ROW_END_CHARPOS (MATRIX_ROW (matrix, w->cursor.vpos))
 18384       && cursor_row_p (MATRIX_ROW (matrix, w->cursor.vpos)))
 18385     {
 18386       struct glyph *g1
 18387         = MATRIX_ROW_GLYPH_START (matrix, w->cursor.vpos) + w->cursor.hpos;
 18388 
 18389       /* Don't consider glyphs that are outside TEXT_AREA.  */
 18390       if (!(row->reversed_p ? glyph > glyphs_end : glyph < glyphs_end))
 18391         return false;
 18392       /* Keep the candidate whose buffer position is the closest to
 18393          point or has the `cursor' property.  */
 18394       if (/* Previous candidate is a glyph in TEXT_AREA of that row.  */
 18395           w->cursor.hpos >= 0
 18396           && w->cursor.hpos < MATRIX_ROW_USED (matrix, w->cursor.vpos)
 18397           && ((BUFFERP (g1->object)
 18398                && (g1->charpos == pt_old /* An exact match always wins.  */
 18399                    || (BUFFERP (glyph->object)
 18400                        && eabs (g1->charpos - pt_old)
 18401                        < eabs (glyph->charpos - pt_old))))
 18402               /* Previous candidate is a glyph from a string that has
 18403                  a non-nil `cursor' property.  */
 18404               || (STRINGP (g1->object)
 18405                   && (!NILP (Fget_char_property (make_fixnum (g1->charpos),
 18406                                                 Qcursor, g1->object))
 18407                       /* Previous candidate is from the same display
 18408                          string as this one, and the display string
 18409                          came from a text property.  */
 18410                       || (EQ (g1->object, glyph->object)
 18411                           && string_from_text_prop)
 18412                       /* this candidate is from newline and its
 18413                          position is not an exact match */
 18414                       || (NILP (glyph->object)
 18415                           && glyph->charpos != pt_old)))))
 18416         return false;
 18417       /* If this candidate gives an exact match, use that.  */
 18418       if (!((BUFFERP (glyph->object) && glyph->charpos == pt_old)
 18419             /* If this candidate is a glyph created for the
 18420                terminating newline of a line, and point is on that
 18421                newline, it wins because it's an exact match.  */
 18422             || (!row->continued_p
 18423                 && NILP (glyph->object)
 18424                 && glyph->charpos == 0
 18425                 && pt_old == MATRIX_ROW_END_CHARPOS (row) - 1))
 18426           /* Otherwise, keep the candidate that comes from a row
 18427              spanning less buffer positions.  This may win when one or
 18428              both candidate positions are on glyphs that came from
 18429              display strings, for which we cannot compare buffer
 18430              positions.  */
 18431           && MATRIX_ROW_END_CHARPOS (MATRIX_ROW (matrix, w->cursor.vpos))
 18432              - MATRIX_ROW_START_CHARPOS (MATRIX_ROW (matrix, w->cursor.vpos))
 18433              < MATRIX_ROW_END_CHARPOS (row) - MATRIX_ROW_START_CHARPOS (row))
 18434         return false;
 18435     }
 18436   w->cursor.hpos = glyph - row->glyphs[TEXT_AREA];
 18437   w->cursor.x = x;
 18438   w->cursor.vpos = MATRIX_ROW_VPOS (row, matrix) + dvpos;
 18439   w->cursor.y = row->y + dy;
 18440 
 18441   if (w == XWINDOW (selected_window))
 18442     {
 18443       if (!row->continued_p
 18444           && !MATRIX_ROW_CONTINUATION_LINE_P (row)
 18445           && row->x == 0)
 18446         {
 18447           this_line_buffer = XBUFFER (w->contents);
 18448 
 18449           CHARPOS (this_line_start_pos)
 18450             = MATRIX_ROW_START_CHARPOS (row) + delta;
 18451           BYTEPOS (this_line_start_pos)
 18452             = MATRIX_ROW_START_BYTEPOS (row) + delta_bytes;
 18453 
 18454           CHARPOS (this_line_end_pos)
 18455             = Z - (MATRIX_ROW_END_CHARPOS (row) + delta);
 18456           BYTEPOS (this_line_end_pos)
 18457             = Z_BYTE - (MATRIX_ROW_END_BYTEPOS (row) + delta_bytes);
 18458 
 18459           this_line_y = w->cursor.y;
 18460           this_line_pixel_height = row->height;
 18461           this_line_vpos = w->cursor.vpos;
 18462           this_line_start_x = row->x;
 18463         }
 18464       else
 18465         CHARPOS (this_line_start_pos) = 0;
 18466     }
 18467 
 18468   return true;
 18469 }
 18470 
 18471 
 18472 /* Run window scroll functions, if any, for WINDOW with new window
 18473    start STARTP.  Sets the window start of WINDOW to that position.
 18474 
 18475    We assume that the window's buffer is really current.  */
 18476 
 18477 static struct text_pos
 18478 run_window_scroll_functions (Lisp_Object window, struct text_pos startp)
 18479 {
 18480   struct window *w = XWINDOW (window);
 18481   SET_MARKER_FROM_TEXT_POS (w->start, startp);
 18482 
 18483   eassert (current_buffer == XBUFFER (w->contents));
 18484 
 18485   if (!NILP (Vwindow_scroll_functions))
 18486     {
 18487       specpdl_ref count = SPECPDL_INDEX ();
 18488       specbind (Qinhibit_quit, Qt);
 18489       safe_run_hooks_2
 18490         (Qwindow_scroll_functions, window, make_fixnum (CHARPOS (startp)));
 18491       unbind_to (count, Qnil);
 18492       SET_TEXT_POS_FROM_MARKER (startp, w->start);
 18493       /* In case the hook functions switch buffers.  */
 18494       set_buffer_internal (XBUFFER (w->contents));
 18495     }
 18496 
 18497   return startp;
 18498 }
 18499 
 18500 
 18501 /* Make sure the line containing the cursor is fully visible.
 18502    A value of true means there is nothing to be done.
 18503    (Either the line is fully visible, or it cannot be made so,
 18504    or we cannot tell.)
 18505 
 18506    If FORCE_P, return false even if partial visible cursor row
 18507    is higher than window.
 18508 
 18509    If CURRENT_MATRIX_P, use the information from the
 18510    window's current glyph matrix; otherwise use the desired glyph
 18511    matrix.
 18512 
 18513    If JUST_TEST_USER_PREFERENCE_P, just test what the value of
 18514    make-cursor-row-fully-visible requires, don't test the actual
 18515    cursor position.  The assumption is that in that case the caller
 18516    performs the necessary testing of the cursor position.
 18517 
 18518    A value of false means the caller should do scrolling
 18519    as if point had gone off the screen.  */
 18520 
 18521 static bool
 18522 cursor_row_fully_visible_p (struct window *w, bool force_p,
 18523                             bool current_matrix_p,
 18524                             bool just_test_user_preference_p)
 18525 {
 18526   struct glyph_matrix *matrix;
 18527   struct glyph_row *row;
 18528   int window_height;
 18529   Lisp_Object mclfv_p =
 18530     buffer_local_value (Qmake_cursor_line_fully_visible, w->contents);
 18531 
 18532   /* If no local binding, use the global value.  */
 18533   if (BASE_EQ (mclfv_p, Qunbound))
 18534     mclfv_p = Vmake_cursor_line_fully_visible;
 18535   /* Follow mode sets the variable to a Lisp function in buffers that
 18536      are under Follow mode.  */
 18537   if (FUNCTIONP (mclfv_p))
 18538     {
 18539       Lisp_Object window;
 18540       XSETWINDOW (window, w);
 18541       /* Implementation note: if the function we call here signals an
 18542          error, we will NOT scroll when the cursor is partially-visible.  */
 18543       Lisp_Object val = safe_call1 (mclfv_p, window);
 18544       if (NILP (val))
 18545         return true;
 18546       else if (just_test_user_preference_p)
 18547         return false;
 18548     }
 18549   else if (NILP (mclfv_p))
 18550     return true;
 18551   else if (just_test_user_preference_p)
 18552     return false;
 18553 
 18554   /* It's not always possible to find the cursor, e.g, when a window
 18555      is full of overlay strings.  Don't do anything in that case.  */
 18556   if (w->cursor.vpos < 0)
 18557     return true;
 18558 
 18559   matrix = current_matrix_p ? w->current_matrix : w->desired_matrix;
 18560   row = MATRIX_ROW (matrix, w->cursor.vpos);
 18561 
 18562   /* If the cursor row is not partially visible, there's nothing to do.  */
 18563   if (!MATRIX_ROW_PARTIALLY_VISIBLE_P (w, row))
 18564     return true;
 18565 
 18566   /* If the row the cursor is in is taller than the window's height,
 18567      it's not clear what to do, so do nothing.  */
 18568   window_height = window_box_height (w);
 18569   if (row->height >= window_height)
 18570     {
 18571       if (!force_p || MINI_WINDOW_P (w)
 18572           || w->vscroll || w->cursor.vpos == 0)
 18573         return true;
 18574     }
 18575   return false;
 18576 }
 18577 
 18578 
 18579 /* Try scrolling PT into view in window WINDOW.  JUST_THIS_ONE_P
 18580    means only WINDOW is redisplayed in redisplay_internal.
 18581    TEMP_SCROLL_STEP has the same meaning as emacs_scroll_step, and is used
 18582    in redisplay_window to bring a partially visible line into view in
 18583    the case that only the cursor has moved.
 18584 
 18585    LAST_LINE_MISFIT should be true if we're scrolling because the
 18586    last screen line's vertical height extends past the end of the screen.
 18587 
 18588    Value is
 18589 
 18590    1    if scrolling succeeded
 18591 
 18592    0    if scrolling didn't find point.
 18593 
 18594    -1   if new fonts have been loaded so that we must interrupt
 18595    redisplay, adjust glyph matrices, and try again.  */
 18596 
 18597 enum
 18598 {
 18599   SCROLLING_SUCCESS = 1,
 18600   SCROLLING_FAILED = 0,
 18601   SCROLLING_NEED_LARGER_MATRICES = -1
 18602 };
 18603 
 18604 /* If scroll-conservatively is more than this, never recenter.
 18605 
 18606    If you change this, don't forget to update the doc string of
 18607    `scroll-conservatively' and the Emacs manual.  */
 18608 #define SCROLL_LIMIT 100
 18609 
 18610 static int
 18611 try_scrolling (Lisp_Object window, bool just_this_one_p,
 18612                intmax_t arg_scroll_conservatively, intmax_t scroll_step,
 18613                bool temp_scroll_step, bool last_line_misfit)
 18614 {
 18615   struct window *w = XWINDOW (window);
 18616   struct text_pos pos, startp;
 18617   struct it it;
 18618   int this_scroll_margin, scroll_max, rc, height;
 18619   int dy = 0, amount_to_scroll = 0;
 18620   bool scroll_down_p = false;
 18621   int extra_scroll_margin_lines = last_line_misfit;
 18622   Lisp_Object aggressive;
 18623   /* We will never try scrolling more than this number of lines.  */
 18624   int scroll_limit = SCROLL_LIMIT;
 18625   int frame_line_height = default_line_pixel_height (w);
 18626 
 18627 #ifdef GLYPH_DEBUG
 18628   debug_method_add (w, "try_scrolling");
 18629 #endif
 18630 
 18631   SET_TEXT_POS_FROM_MARKER (startp, w->start);
 18632 
 18633   this_scroll_margin = window_scroll_margin (w, MARGIN_IN_PIXELS);
 18634 
 18635   /* Force arg_scroll_conservatively to have a reasonable value, to
 18636      avoid scrolling too far away with slow move_it_* functions.  Note
 18637      that the user can supply scroll-conservatively equal to
 18638      `most-positive-fixnum', which can be larger than INT_MAX.  */
 18639   if (arg_scroll_conservatively > scroll_limit)
 18640     {
 18641       arg_scroll_conservatively = scroll_limit + 1;
 18642       scroll_max = scroll_limit * frame_line_height;
 18643     }
 18644   else if (0 < scroll_step || 0 < arg_scroll_conservatively || temp_scroll_step)
 18645     /* Compute how much we should try to scroll maximally to bring
 18646        point into view.  */
 18647     {
 18648       intmax_t scroll_lines_max
 18649         = max (scroll_step, max (arg_scroll_conservatively, temp_scroll_step));
 18650       int scroll_lines = clip_to_bounds (0, scroll_lines_max, 1000000);
 18651       scroll_max = scroll_lines * frame_line_height;
 18652     }
 18653   else if (NUMBERP (BVAR (current_buffer, scroll_down_aggressively))
 18654            || NUMBERP (BVAR (current_buffer, scroll_up_aggressively)))
 18655     /* We're trying to scroll because of aggressive scrolling but no
 18656        scroll_step is set.  Choose an arbitrary one.  */
 18657     scroll_max = 10 * frame_line_height;
 18658   else
 18659     scroll_max = 0;
 18660 
 18661  too_near_end:
 18662 
 18663   /* Decide whether to scroll down.  */
 18664   if (PT > CHARPOS (startp))
 18665     {
 18666       int scroll_margin_y;
 18667 
 18668       /* Compute the pixel ypos of the scroll margin, then move IT to
 18669          either that ypos or PT, whichever comes first.  */
 18670       start_display (&it, w, startp);
 18671       scroll_margin_y = it.last_visible_y - partial_line_height (&it)
 18672         - this_scroll_margin
 18673         - frame_line_height * extra_scroll_margin_lines;
 18674       move_it_to (&it, PT, -1, scroll_margin_y - 1, -1,
 18675                   (MOVE_TO_POS | MOVE_TO_Y));
 18676 
 18677       if (PT > CHARPOS (it.current.pos))
 18678         {
 18679           int y0 = line_bottom_y (&it);
 18680           /* Compute how many pixels below window bottom to stop searching
 18681              for PT.  This avoids costly search for PT that is far away if
 18682              the user limited scrolling by a small number of lines, but
 18683              always finds PT if scroll_conservatively is set to a large
 18684              number, such as most-positive-fixnum.  */
 18685           int slack = max (scroll_max, 10 * frame_line_height);
 18686           int y_to_move = it.last_visible_y + slack;
 18687 
 18688           /* Compute the distance from the scroll margin to PT or to
 18689              the scroll limit, whichever comes first.  This should
 18690              include the height of the cursor line, to make that line
 18691              fully visible.  */
 18692           move_it_to (&it, PT, -1, y_to_move,
 18693                       -1, MOVE_TO_POS | MOVE_TO_Y);
 18694           dy = line_bottom_y (&it) - y0;
 18695 
 18696           if (dy > scroll_max)
 18697             return SCROLLING_FAILED;
 18698 
 18699           if (dy > 0)
 18700             scroll_down_p = true;
 18701         }
 18702       else if (PT == IT_CHARPOS (it)
 18703                && IT_CHARPOS (it) < ZV
 18704                && it.method == GET_FROM_STRING
 18705                && arg_scroll_conservatively > scroll_limit
 18706                && it.current_x == 0)
 18707         {
 18708           enum move_it_result skip;
 18709           int y1 = it.current_y;
 18710           int vpos;
 18711 
 18712           /* A before-string that includes newlines and is displayed
 18713              on the last visible screen line could fail us under
 18714              scroll-conservatively > 100, because we will be unable to
 18715              position the cursor on that last visible line.  Try to
 18716              recover by finding the first screen line that has some
 18717              glyphs coming from the buffer text.  */
 18718           do {
 18719             skip = move_it_in_display_line_to (&it, ZV, -1, MOVE_TO_POS);
 18720             if (skip != MOVE_NEWLINE_OR_CR
 18721                 || IT_CHARPOS (it) != PT
 18722                 || it.method == GET_FROM_BUFFER)
 18723               break;
 18724             vpos = it.vpos;
 18725             move_it_to (&it, -1, -1, -1, vpos + 1, MOVE_TO_VPOS);
 18726           } while (it.vpos > vpos);
 18727 
 18728           dy = it.current_y - y1;
 18729 
 18730           if (dy > scroll_max)
 18731             return SCROLLING_FAILED;
 18732 
 18733           if (dy > 0)
 18734             scroll_down_p = true;
 18735         }
 18736     }
 18737 
 18738   if (scroll_down_p)
 18739     {
 18740       /* Point is in or below the bottom scroll margin, so move the
 18741          window start down.  If scrolling conservatively, move it just
 18742          enough down to make point visible.  If scroll_step is set,
 18743          move it down by scroll_step.  */
 18744       if (arg_scroll_conservatively)
 18745         amount_to_scroll
 18746           = min (max (dy, frame_line_height),
 18747                  frame_line_height * arg_scroll_conservatively);
 18748       else if (scroll_step || temp_scroll_step)
 18749         amount_to_scroll = scroll_max;
 18750       else
 18751         {
 18752           aggressive = BVAR (current_buffer, scroll_up_aggressively);
 18753           height = WINDOW_BOX_TEXT_HEIGHT (w);
 18754           if (NUMBERP (aggressive))
 18755             {
 18756               double float_amount = XFLOATINT (aggressive) * height;
 18757               int aggressive_scroll = float_amount;
 18758               if (aggressive_scroll == 0 && float_amount > 0)
 18759                 aggressive_scroll = 1;
 18760               /* Don't let point enter the scroll margin near top of
 18761                  the window.  This could happen if the value of
 18762                  scroll_up_aggressively is too large and there are
 18763                  non-zero margins, because scroll_up_aggressively
 18764                  means put point that fraction of window height
 18765                  _from_the_bottom_margin_.  */
 18766               if (aggressive_scroll + 2 * this_scroll_margin > height)
 18767                 aggressive_scroll = height - 2 * this_scroll_margin;
 18768               amount_to_scroll = dy + aggressive_scroll;
 18769             }
 18770         }
 18771 
 18772       if (amount_to_scroll <= 0)
 18773         return SCROLLING_FAILED;
 18774 
 18775       start_display (&it, w, startp);
 18776       if (arg_scroll_conservatively <= scroll_limit)
 18777         move_it_vertically (&it, amount_to_scroll);
 18778       else
 18779         {
 18780           /* Extra precision for users who set scroll-conservatively
 18781              to a large number: make sure the amount we scroll
 18782              the window start is never less than amount_to_scroll,
 18783              which was computed as distance from window bottom to
 18784              point.  This matters when lines at window top and lines
 18785              below window bottom have different height.  */
 18786           struct it it1;
 18787           void *it1data = NULL;
 18788           /* We use a temporary it1 because line_bottom_y can modify
 18789              its argument, if it moves one line down; see there.  */
 18790           int start_y;
 18791 
 18792           SAVE_IT (it1, it, it1data);
 18793           start_y = line_bottom_y (&it1);
 18794           do {
 18795             RESTORE_IT (&it, &it, it1data);
 18796             move_it_by_lines (&it, 1);
 18797             SAVE_IT (it1, it, it1data);
 18798           } while (IT_CHARPOS (it) < ZV
 18799                    && line_bottom_y (&it1) - start_y < amount_to_scroll);
 18800           bidi_unshelve_cache (it1data, true);
 18801         }
 18802 
 18803       /* If STARTP is unchanged, move it down another screen line.  */
 18804       if (IT_CHARPOS (it) == CHARPOS (startp))
 18805         move_it_by_lines (&it, 1);
 18806       startp = it.current.pos;
 18807     }
 18808   else
 18809     {
 18810       struct text_pos scroll_margin_pos = startp;
 18811       int y_offset = 0;
 18812 
 18813       /* See if point is inside the scroll margin at the top of the
 18814          window.  */
 18815       if (this_scroll_margin)
 18816         {
 18817           int y_start;
 18818 
 18819           start_display (&it, w, startp);
 18820           y_start = it.current_y;
 18821           move_it_vertically (&it, this_scroll_margin);
 18822           scroll_margin_pos = it.current.pos;
 18823           /* If we didn't move enough before hitting ZV, request
 18824              additional amount of scroll, to move point out of the
 18825              scroll margin.  */
 18826           if (IT_CHARPOS (it) == ZV
 18827               && it.current_y - y_start < this_scroll_margin)
 18828             y_offset = this_scroll_margin - (it.current_y - y_start);
 18829         }
 18830 
 18831       if (PT < CHARPOS (scroll_margin_pos))
 18832         {
 18833           /* Point is in the scroll margin at the top of the window or
 18834              above what is displayed in the window.  */
 18835           int y0, y_to_move;
 18836 
 18837           /* Compute the vertical distance from PT to the scroll
 18838              margin position.  Move as far as scroll_max allows, or
 18839              one screenful, or 10 screen lines, whichever is largest.
 18840              Give up if distance is greater than scroll_max or if we
 18841              didn't reach the scroll margin position.  */
 18842           SET_TEXT_POS (pos, PT, PT_BYTE);
 18843           start_display (&it, w, pos);
 18844           y0 = it.current_y;
 18845           y_to_move = max (it.last_visible_y,
 18846                            max (scroll_max, 10 * frame_line_height));
 18847           move_it_to (&it, CHARPOS (scroll_margin_pos), 0,
 18848                       y_to_move, -1,
 18849                       MOVE_TO_POS | MOVE_TO_X | MOVE_TO_Y);
 18850           dy = it.current_y - y0;
 18851           if (dy > scroll_max
 18852               || IT_CHARPOS (it) < CHARPOS (scroll_margin_pos))
 18853             return SCROLLING_FAILED;
 18854 
 18855           /* Additional scroll for when ZV was too close to point.  */
 18856           dy += y_offset;
 18857 
 18858           /* Compute new window start.  */
 18859           start_display (&it, w, startp);
 18860 
 18861           if (arg_scroll_conservatively)
 18862             amount_to_scroll
 18863               = min (max (dy, frame_line_height),
 18864                      frame_line_height * arg_scroll_conservatively);
 18865           else if (scroll_step || temp_scroll_step)
 18866             amount_to_scroll = scroll_max;
 18867           else
 18868             {
 18869               aggressive = BVAR (current_buffer, scroll_down_aggressively);
 18870               height = WINDOW_BOX_TEXT_HEIGHT (w);
 18871               if (NUMBERP (aggressive))
 18872                 {
 18873                   double float_amount = XFLOATINT (aggressive) * height;
 18874                   int aggressive_scroll = float_amount;
 18875                   if (aggressive_scroll == 0 && float_amount > 0)
 18876                     aggressive_scroll = 1;
 18877                   /* Don't let point enter the scroll margin near
 18878                      bottom of the window, if the value of
 18879                      scroll_down_aggressively happens to be too
 18880                      large.  */
 18881                   if (aggressive_scroll + 2 * this_scroll_margin > height)
 18882                     aggressive_scroll = height - 2 * this_scroll_margin;
 18883                   amount_to_scroll = dy + aggressive_scroll;
 18884                 }
 18885             }
 18886 
 18887           if (amount_to_scroll <= 0)
 18888             return SCROLLING_FAILED;
 18889 
 18890           move_it_vertically_backward (&it, amount_to_scroll);
 18891           startp = it.current.pos;
 18892         }
 18893     }
 18894 
 18895   /* Run window scroll functions.  */
 18896   startp = run_window_scroll_functions (window, startp);
 18897 
 18898   /* Display the window.  Give up if new fonts are loaded, or if point
 18899      doesn't appear.  */
 18900   if (!try_window (window, startp, 0))
 18901     rc = SCROLLING_NEED_LARGER_MATRICES;
 18902   else if (w->cursor.vpos < 0)
 18903     {
 18904       clear_glyph_matrix (w->desired_matrix);
 18905       rc = SCROLLING_FAILED;
 18906     }
 18907   else
 18908     {
 18909       /* Maybe forget recorded base line for line number display.  */
 18910       if (!just_this_one_p
 18911           || current_buffer->clip_changed
 18912           || BEG_UNCHANGED < CHARPOS (startp))
 18913         w->base_line_number = 0;
 18914 
 18915       /* If cursor ends up on a partially visible line,
 18916          treat that as being off the bottom of the screen.  */
 18917       if (! cursor_row_fully_visible_p (w, extra_scroll_margin_lines <= 1,
 18918                                         false, false)
 18919           /* It's possible that the cursor is on the first line of the
 18920              buffer, which is partially obscured due to a vscroll
 18921              (Bug#7537).  In that case, avoid looping forever. */
 18922           && extra_scroll_margin_lines < w->desired_matrix->nrows - 1)
 18923         {
 18924           clear_glyph_matrix (w->desired_matrix);
 18925           ++extra_scroll_margin_lines;
 18926           goto too_near_end;
 18927         }
 18928       rc = SCROLLING_SUCCESS;
 18929     }
 18930 
 18931   return rc;
 18932 }
 18933 
 18934 
 18935 /* Compute a suitable window start for window W if display of W starts
 18936    on a continuation line.  Value is true if a new window start
 18937    was computed.
 18938 
 18939    The new window start will be computed, based on W's width, starting
 18940    from the start of the continued line.  It is the start of the
 18941    screen line with the minimum distance from the old start W->start,
 18942    which is still before point (otherwise point will definitely not
 18943    be visible in the window).  */
 18944 
 18945 static bool
 18946 compute_window_start_on_continuation_line (struct window *w)
 18947 {
 18948   struct text_pos pos, start_pos, pos_before_pt;
 18949   bool window_start_changed_p = false;
 18950 
 18951   SET_TEXT_POS_FROM_MARKER (start_pos, w->start);
 18952 
 18953   /* If window start is on a continuation line...  Window start may be
 18954      < BEGV in case there's invisible text at the start of the
 18955      buffer (M-x rmail, for example).  */
 18956   if (CHARPOS (start_pos) > BEGV
 18957       && FETCH_BYTE (BYTEPOS (start_pos) - 1) != '\n')
 18958     {
 18959       struct it it;
 18960       struct glyph_row *row;
 18961 
 18962       /* Handle the case that the window start is out of range.  */
 18963       if (CHARPOS (start_pos) < BEGV)
 18964         SET_TEXT_POS (start_pos, BEGV, BEGV_BYTE);
 18965       else if (CHARPOS (start_pos) > ZV)
 18966         SET_TEXT_POS (start_pos, ZV, ZV_BYTE);
 18967 
 18968       /* Find the start of the continued line.  This should be fast
 18969          because find_newline is fast (newline cache).  */
 18970       row = w->desired_matrix->rows + window_wants_tab_line (w)
 18971                                     + window_wants_header_line (w);
 18972       init_iterator (&it, w, CHARPOS (start_pos), BYTEPOS (start_pos),
 18973                      row, DEFAULT_FACE_ID);
 18974       reseat_at_previous_visible_line_start (&it);
 18975 
 18976       /* Give up (by not using the code in the block below) and say it
 18977          takes too much time to compute a new window start, if the
 18978          line start is "too far" away from the window start.  Also,
 18979          give up if the line start is after point, as in that case
 18980          point will not be visible with any window start we
 18981          compute.  */
 18982       if (IT_CHARPOS (it) <= PT
 18983           && (CHARPOS (start_pos) - IT_CHARPOS (it)
 18984               /* PXW: Do we need upper bounds here?  */
 18985               < WINDOW_TOTAL_LINES (w) * WINDOW_TOTAL_COLS (w)))
 18986         {
 18987           int min_distance, distance;
 18988 
 18989           /* Move forward by display lines to find the new window
 18990              start.  If window width was enlarged, the new start can
 18991              be expected to be > the old start.  If window width was
 18992              decreased, the new window start will be < the old start.
 18993              So, we're looking for the display line start with the
 18994              minimum distance from the old window start.  */
 18995           pos_before_pt = pos = it.current.pos;
 18996           min_distance = DISP_INFINITY;
 18997           while ((distance = eabs (CHARPOS (start_pos) - IT_CHARPOS (it))),
 18998                  distance < min_distance)
 18999             {
 19000               min_distance = distance;
 19001               if (CHARPOS (pos) <= PT)
 19002                 pos_before_pt = pos;
 19003               pos = it.current.pos;
 19004               if (it.line_wrap == WORD_WRAP)
 19005                 {
 19006                   /* Under WORD_WRAP, move_it_by_lines is likely to
 19007                      overshoot and stop not at the first, but the
 19008                      second character from the left margin.  So in
 19009                      that case, we need a more tight control on the X
 19010                      coordinate of the iterator than move_it_by_lines
 19011                      promises in its contract.  The method is to first
 19012                      go to the last (rightmost) visible character of a
 19013                      line, then move to the leftmost character on the
 19014                      next line in a separate call.  */
 19015                   move_it_to (&it, ZV, it.last_visible_x, it.current_y, -1,
 19016                               MOVE_TO_POS | MOVE_TO_X | MOVE_TO_Y);
 19017                   move_it_to (&it, ZV, 0,
 19018                               it.current_y + it.max_ascent + it.max_descent, -1,
 19019                               MOVE_TO_POS | MOVE_TO_X | MOVE_TO_Y);
 19020                 }
 19021               else
 19022                 move_it_by_lines (&it, 1);
 19023             }
 19024 
 19025           /* It makes very little sense to make the new window start
 19026              after point, as point won't be visible.  If that's what
 19027              the loop above finds, fall back on the candidate before
 19028              or at point that is closest to the old window start.  */
 19029           if (CHARPOS (pos) > PT)
 19030             pos = pos_before_pt;
 19031 
 19032           /* Set the window start there.  */
 19033           SET_MARKER_FROM_TEXT_POS (w->start, pos);
 19034           window_start_changed_p = true;
 19035         }
 19036     }
 19037 
 19038   return window_start_changed_p;
 19039 }
 19040 
 19041 
 19042 /* Try cursor movement in case text has not changed in window WINDOW,
 19043    with window start STARTP.  Value is
 19044 
 19045    CURSOR_MOVEMENT_SUCCESS if successful
 19046 
 19047    CURSOR_MOVEMENT_CANNOT_BE_USED if this method cannot be used
 19048 
 19049    CURSOR_MOVEMENT_MUST_SCROLL if we know we have to scroll the
 19050    display.  *SCROLL_STEP is set to true, under certain circumstances, if
 19051    we want to scroll as if scroll-step were set to 1.  See the code.
 19052 
 19053    CURSOR_MOVEMENT_NEED_LARGER_MATRICES if we need larger matrices, in
 19054    which case we have to abort this redisplay, and adjust matrices
 19055    first.  */
 19056 
 19057 enum
 19058 {
 19059   CURSOR_MOVEMENT_SUCCESS,
 19060   CURSOR_MOVEMENT_CANNOT_BE_USED,
 19061   CURSOR_MOVEMENT_MUST_SCROLL,
 19062   CURSOR_MOVEMENT_NEED_LARGER_MATRICES
 19063 };
 19064 
 19065 static int
 19066 try_cursor_movement (Lisp_Object window, struct text_pos startp,
 19067                      bool *scroll_step)
 19068 {
 19069   struct window *w = XWINDOW (window);
 19070   struct frame *f = XFRAME (w->frame);
 19071   int rc = CURSOR_MOVEMENT_CANNOT_BE_USED;
 19072 
 19073 #ifdef GLYPH_DEBUG
 19074   if (inhibit_try_cursor_movement)
 19075     return rc;
 19076 #endif
 19077 
 19078   /* Previously, there was a check for Lisp integer in the
 19079      if-statement below. Now, this field is converted to
 19080      ptrdiff_t, thus zero means invalid position in a buffer.  */
 19081   eassert (w->last_point > 0);
 19082   /* Likewise there was a check whether window_end_vpos is nil or larger
 19083      than the window.  Now window_end_vpos is int and so never nil, but
 19084      let's leave eassert to check whether it fits in the window.  */
 19085   eassert (!w->window_end_valid
 19086            || w->window_end_vpos < w->current_matrix->nrows);
 19087 
 19088   /* Handle case where text has not changed, only point, and it has
 19089      not moved off the frame.  */
 19090   if (/* Point may be in this window.  */
 19091       PT >= CHARPOS (startp)
 19092       /* Selective display hasn't changed.  */
 19093       && !current_buffer->clip_changed
 19094       /* Function force-mode-line-update is used to force a thorough
 19095          redisplay.  It sets either windows_or_buffers_changed or
 19096          update_mode_lines.  So don't take a shortcut here for these
 19097          cases.  */
 19098       && !update_mode_lines
 19099       && !windows_or_buffers_changed
 19100       && !f->cursor_type_changed
 19101       && NILP (Vshow_trailing_whitespace)
 19102       /* When display-line-numbers is in relative mode, moving point
 19103          requires to redraw the entire window.  */
 19104       && !EQ (Vdisplay_line_numbers, Qrelative)
 19105       && !EQ (Vdisplay_line_numbers, Qvisual)
 19106       /* When the current line number should be displayed in a
 19107          distinct face, moving point cannot be handled in optimized
 19108          way as below.  */
 19109       && !(!NILP (Vdisplay_line_numbers)
 19110            && NILP (Finternal_lisp_face_equal_p (Qline_number,
 19111                                                  Qline_number_current_line,
 19112                                                  w->frame)))
 19113       /* This code is not used for mini-buffer for the sake of the case
 19114          of redisplaying to replace an echo area message; since in
 19115          that case the mini-buffer contents per se are usually
 19116          unchanged.  This code is of no real use in the mini-buffer
 19117          since the handling of this_line_start_pos, etc., in redisplay
 19118          handles the same cases.  */
 19119       && !EQ (window, minibuf_window)
 19120       /* When overlay arrow is shown in current buffer, point movement
 19121          is no longer "simple", as it typically causes the overlay
 19122          arrow to move as well.  */
 19123       && !overlay_arrow_in_current_buffer_p ())
 19124     {
 19125       int this_scroll_margin, top_scroll_margin;
 19126       struct glyph_row *row = NULL;
 19127 
 19128 #ifdef GLYPH_DEBUG
 19129       debug_method_add (w, "cursor movement");
 19130 #endif
 19131 
 19132       this_scroll_margin = window_scroll_margin (w, MARGIN_IN_PIXELS);
 19133 
 19134       top_scroll_margin = this_scroll_margin;
 19135       if (window_wants_tab_line (w))
 19136         top_scroll_margin += CURRENT_TAB_LINE_HEIGHT (w);
 19137       if (window_wants_header_line (w))
 19138         top_scroll_margin += CURRENT_HEADER_LINE_HEIGHT (w);
 19139 
 19140       /* Start with the row the cursor was displayed during the last
 19141          not paused redisplay.  Give up if that row is not valid.  */
 19142       if (w->last_cursor_vpos < 0
 19143           || w->last_cursor_vpos >= w->current_matrix->nrows)
 19144         rc = CURSOR_MOVEMENT_MUST_SCROLL;
 19145       else
 19146         {
 19147           row = MATRIX_ROW (w->current_matrix, w->last_cursor_vpos);
 19148           /* Skip the tab-line and header-line rows, if any.  */
 19149           if (row->tab_line_p)
 19150             ++row;
 19151           if (row->mode_line_p)
 19152             ++row;
 19153           if (!row->enabled_p)
 19154             rc = CURSOR_MOVEMENT_MUST_SCROLL;
 19155         }
 19156 
 19157       if (rc == CURSOR_MOVEMENT_CANNOT_BE_USED)
 19158         {
 19159           bool scroll_p = false, must_scroll = false;
 19160           int last_y = window_text_bottom_y (w) - this_scroll_margin;
 19161 
 19162           if (PT > w->last_point)
 19163             {
 19164               /* Point has moved forward.  */
 19165               while (MATRIX_ROW_END_CHARPOS (row) < PT
 19166                      && MATRIX_ROW_BOTTOM_Y (row) < last_y)
 19167                 {
 19168                   eassert (row->enabled_p);
 19169                   ++row;
 19170                 }
 19171 
 19172               /* If the end position of a row equals the start
 19173                  position of the next row, and PT is at that position,
 19174                  we would rather display cursor in the next line.  */
 19175               while (MATRIX_ROW_BOTTOM_Y (row) < last_y
 19176                      && MATRIX_ROW_END_CHARPOS (row) == PT
 19177                      && row < MATRIX_MODE_LINE_ROW (w->current_matrix)
 19178                      && MATRIX_ROW_START_CHARPOS (row+1) >= PT
 19179                      && !cursor_row_p (row))
 19180                 ++row;
 19181 
 19182               /* If within the scroll margin, scroll.  Note that
 19183                  MATRIX_ROW_BOTTOM_Y gives the pixel position at which
 19184                  the next line would be drawn, and that
 19185                  this_scroll_margin can be zero.  */
 19186               if (MATRIX_ROW_BOTTOM_Y (row) > last_y
 19187                   || PT > MATRIX_ROW_END_CHARPOS (row)
 19188                   /* Line is completely visible last line in window
 19189                      and PT is to be set in the next line.  */
 19190                   || (MATRIX_ROW_BOTTOM_Y (row) == last_y
 19191                       && PT == MATRIX_ROW_END_CHARPOS (row)
 19192                       && !row->ends_at_zv_p
 19193                       && !MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (row)))
 19194                 scroll_p = true;
 19195             }
 19196           else if (PT < w->last_point)
 19197             {
 19198               /* Cursor has to be moved backward.  Note that PT >=
 19199                  CHARPOS (startp) because of the outer if-statement.  */
 19200               struct glyph_row *row0 = row;
 19201 
 19202               while (!row->mode_line_p
 19203                      && (MATRIX_ROW_START_CHARPOS (row) > PT
 19204                          || (MATRIX_ROW_START_CHARPOS (row) == PT
 19205                              && (MATRIX_ROW_STARTS_IN_MIDDLE_OF_CHAR_P (row)
 19206                                  || (/* STARTS_IN_MIDDLE_OF_STRING_P (row) */
 19207                                      row > w->current_matrix->rows
 19208                                      && (row-1)->ends_in_newline_from_string_p))))
 19209                      && (row->y > top_scroll_margin
 19210                          || CHARPOS (startp) == BEGV))
 19211                 {
 19212                   eassert (row->enabled_p);
 19213                   --row;
 19214                 }
 19215 
 19216               /* With bidi-reordered rows we can have buffer positions
 19217                  _decrease_ when going down by rows.  If we haven't
 19218                  found our row in the loop above, give it another try
 19219                  now going in the other direction from the original row.  */
 19220               if (!(MATRIX_ROW_START_CHARPOS (row) <= PT
 19221                     && PT <= MATRIX_ROW_END_CHARPOS (row))
 19222                   && row0->continued_p)
 19223                 {
 19224                   row = row0;
 19225                   while (MATRIX_ROW_START_CHARPOS (row) > PT
 19226                          && MATRIX_ROW_BOTTOM_Y (row) < last_y)
 19227                     {
 19228                       eassert (row->enabled_p);
 19229                       ++row;
 19230                     }
 19231                 }
 19232 
 19233               /* Consider the following case: Window starts at BEGV,
 19234                  there is invisible, intangible text at BEGV, so that
 19235                  display starts at some point START > BEGV.  It can
 19236                  happen that we are called with PT somewhere between
 19237                  BEGV and START.  Try to handle that case.  */
 19238               if (row < w->current_matrix->rows
 19239                   || row->mode_line_p)
 19240                 {
 19241                   row = w->current_matrix->rows;
 19242                   /* Skip the tab-line and header-line rows, if any.  */
 19243                   if (row->tab_line_p)
 19244                     ++row;
 19245                   if (row->mode_line_p)
 19246                     ++row;
 19247                 }
 19248 
 19249               /* Due to newlines in overlay strings, we may have to
 19250                  skip forward over overlay strings.  */
 19251               while (MATRIX_ROW_BOTTOM_Y (row) < last_y
 19252                      && MATRIX_ROW_END_CHARPOS (row) == PT
 19253                      && !cursor_row_p (row))
 19254                 ++row;
 19255 
 19256               /* If within the scroll margin, either the top one or
 19257                  the bottom one, scroll.  */
 19258               if ((row->y < top_scroll_margin
 19259                    && CHARPOS (startp) != BEGV)
 19260                   || MATRIX_ROW_BOTTOM_Y (row) > last_y
 19261                   || PT > MATRIX_ROW_END_CHARPOS (row)
 19262                   || (MATRIX_ROW_BOTTOM_Y (row) == last_y
 19263                       && PT == MATRIX_ROW_END_CHARPOS (row)
 19264                       && !row->ends_at_zv_p
 19265                       && !MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (row)))
 19266                 scroll_p = true;
 19267             }
 19268           else
 19269             {
 19270               /* Cursor did not move.  So don't scroll even if cursor line
 19271                  is partially visible, as it was so before.  */
 19272                  rc = CURSOR_MOVEMENT_SUCCESS;
 19273             }
 19274 
 19275           if ((PT < MATRIX_ROW_START_CHARPOS (row)
 19276                && (row == MATRIX_FIRST_TEXT_ROW (w->current_matrix)
 19277                    /* Don't give up if point is inside invisible text
 19278                       at the beginning of its glyph row.  */
 19279                    || (MATRIX_ROW_END_CHARPOS (row-1)
 19280                        == MATRIX_ROW_START_CHARPOS (row))))
 19281               || PT > MATRIX_ROW_END_CHARPOS (row))
 19282             {
 19283               /* if PT is not in the glyph row, give up.  */
 19284               rc = CURSOR_MOVEMENT_MUST_SCROLL;
 19285               must_scroll = true;
 19286             }
 19287           else if (rc != CURSOR_MOVEMENT_SUCCESS
 19288                    && !NILP (BVAR (XBUFFER (w->contents), bidi_display_reordering)))
 19289             {
 19290               struct glyph_row *row1;
 19291 
 19292               /* If rows are bidi-reordered and point moved, back up
 19293                  until we find a row that does not belong to a
 19294                  continuation line.  This is because we must consider
 19295                  all rows of a continued line as candidates for the
 19296                  new cursor positioning, since row start and end
 19297                  positions change non-linearly with vertical position
 19298                  in such rows.  */
 19299               /* FIXME: Revisit this when glyph ``spilling'' in
 19300                  continuation lines' rows is implemented for
 19301                  bidi-reordered rows.  */
 19302               for (row1 = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
 19303                    MATRIX_ROW_CONTINUATION_LINE_P (row);
 19304                    --row)
 19305                 {
 19306                   /* If we hit the beginning of the displayed portion
 19307                      without finding the first row of a continued
 19308                      line, give up.  */
 19309                   if (row <= row1)
 19310                     {
 19311                       rc = CURSOR_MOVEMENT_MUST_SCROLL;
 19312                       break;
 19313                     }
 19314                   eassert (row->enabled_p);
 19315                 }
 19316             }
 19317           if (must_scroll)
 19318             ;
 19319           else if (rc != CURSOR_MOVEMENT_SUCCESS
 19320               && MATRIX_ROW_PARTIALLY_VISIBLE_P (w, row)
 19321               /* Make sure this isn't a header line nor a tab-line by
 19322                  any chance, since then MATRIX_ROW_PARTIALLY_VISIBLE_P
 19323                  might yield true.  */
 19324               && !row->mode_line_p
 19325               && !cursor_row_fully_visible_p (w, true, true, true))
 19326             {
 19327               if (PT == MATRIX_ROW_END_CHARPOS (row)
 19328                   && !row->ends_at_zv_p
 19329                   && !MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (row))
 19330                 rc = CURSOR_MOVEMENT_MUST_SCROLL;
 19331               else if (row->height > window_box_height (w))
 19332                 {
 19333                   /* If we end up in a partially visible line, let's
 19334                      make it fully visible, except when it's taller
 19335                      than the window, in which case we can't do much
 19336                      about it.  */
 19337                   *scroll_step = true;
 19338                   rc = CURSOR_MOVEMENT_MUST_SCROLL;
 19339                 }
 19340               else
 19341                 {
 19342                   set_cursor_from_row (w, row, w->current_matrix, 0, 0, 0, 0);
 19343                   if (!cursor_row_fully_visible_p (w, false, true, false))
 19344                     rc = CURSOR_MOVEMENT_MUST_SCROLL;
 19345                   else
 19346                     rc = CURSOR_MOVEMENT_SUCCESS;
 19347                 }
 19348             }
 19349           else if (scroll_p)
 19350             rc = CURSOR_MOVEMENT_MUST_SCROLL;
 19351           else if (rc != CURSOR_MOVEMENT_SUCCESS
 19352                    && !NILP (BVAR (XBUFFER (w->contents), bidi_display_reordering)))
 19353             {
 19354               /* With bidi-reordered rows, there could be more than
 19355                  one candidate row whose start and end positions
 19356                  occlude point.  We need to let set_cursor_from_row
 19357                  find the best candidate.  */
 19358               /* FIXME: Revisit this when glyph ``spilling'' in
 19359                  continuation lines' rows is implemented for
 19360                  bidi-reordered rows.  */
 19361               bool rv = false;
 19362               bool pt_invis = false;
 19363               Lisp_Object val = get_char_property_and_overlay (make_fixnum (PT),
 19364                                                                Qinvisible,
 19365                                                                Qnil, NULL);
 19366 
 19367               if (TEXT_PROP_MEANS_INVISIBLE (val) != 0)
 19368                 pt_invis = true;
 19369 
 19370               do
 19371                 {
 19372                   bool at_zv_p = false, exact_match_p = false;
 19373 
 19374                   /* If point is in invisible text, we cannot assume
 19375                      it must be after row's start position, since the
 19376                      row could have invisible text at its beginning
 19377                      where point is located.  */
 19378                   if ((pt_invis || MATRIX_ROW_START_CHARPOS (row) <= PT)
 19379                       && PT <= MATRIX_ROW_END_CHARPOS (row)
 19380                       && cursor_row_p (row))
 19381                     rv |= set_cursor_from_row (w, row, w->current_matrix,
 19382                                                0, 0, 0, 0);
 19383                   /* As soon as we've found the exact match for point,
 19384                      or the first suitable row whose ends_at_zv_p flag
 19385                      is set, we are done.  */
 19386                   if (rv)
 19387                     {
 19388                       at_zv_p = MATRIX_ROW (w->current_matrix,
 19389                                             w->cursor.vpos)->ends_at_zv_p;
 19390                       if (!at_zv_p
 19391                           && w->cursor.hpos >= 0
 19392                           && w->cursor.hpos < MATRIX_ROW_USED (w->current_matrix,
 19393                                                                w->cursor.vpos))
 19394                         {
 19395                           struct glyph_row *candidate =
 19396                             MATRIX_ROW (w->current_matrix, w->cursor.vpos);
 19397                           struct glyph *g =
 19398                             candidate->glyphs[TEXT_AREA] + w->cursor.hpos;
 19399                           ptrdiff_t endpos = MATRIX_ROW_END_CHARPOS (candidate);
 19400 
 19401                           exact_match_p =
 19402                             (BUFFERP (g->object) && g->charpos == PT)
 19403                             || (NILP (g->object)
 19404                                 && (g->charpos == PT
 19405                                     || (g->charpos == 0 && endpos - 1 == PT)));
 19406                           /* Perhaps the point position is inside
 19407                              invisible text?  In that case, we trust
 19408                              'set_cursor_from_row' to do its job and
 19409                              find the best position for the cursor.  */
 19410                           if (!exact_match_p && pt_invis)
 19411                             exact_match_p = true;
 19412                         }
 19413                       if (at_zv_p || exact_match_p)
 19414                         {
 19415                           rc = CURSOR_MOVEMENT_SUCCESS;
 19416                           break;
 19417                         }
 19418                     }
 19419                   if (MATRIX_ROW_BOTTOM_Y (row) == last_y)
 19420                     break;
 19421                   ++row;
 19422                 }
 19423               while (((MATRIX_ROW_CONTINUATION_LINE_P (row)
 19424                        || row->continued_p)
 19425                       && MATRIX_ROW_BOTTOM_Y (row) <= last_y)
 19426                      || (MATRIX_ROW_START_CHARPOS (row) == PT
 19427                          && MATRIX_ROW_BOTTOM_Y (row) < last_y));
 19428               /* If we didn't find any candidate rows, or exited the
 19429                  loop before all the candidates were examined, signal
 19430                  to the caller that this method failed.  */
 19431               if (rc != CURSOR_MOVEMENT_SUCCESS
 19432                   && !(rv
 19433                        && !MATRIX_ROW_CONTINUATION_LINE_P (row)
 19434                        && !row->continued_p))
 19435                 rc = CURSOR_MOVEMENT_MUST_SCROLL;
 19436               else if (rv)
 19437                 rc = CURSOR_MOVEMENT_SUCCESS;
 19438             }
 19439           else
 19440             {
 19441               do
 19442                 {
 19443                   if (set_cursor_from_row (w, row, w->current_matrix, 0, 0, 0, 0))
 19444                     {
 19445                       rc = CURSOR_MOVEMENT_SUCCESS;
 19446                       break;
 19447                     }
 19448                   ++row;
 19449                 }
 19450               while (MATRIX_ROW_BOTTOM_Y (row) < last_y
 19451                      && MATRIX_ROW_START_CHARPOS (row) == PT
 19452                      && cursor_row_p (row));
 19453             }
 19454         }
 19455     }
 19456 
 19457   return rc;
 19458 }
 19459 
 19460 
 19461 void
 19462 set_vertical_scroll_bar (struct window *w)
 19463 {
 19464   ptrdiff_t start, end, whole;
 19465 
 19466   /* Calculate the start and end positions for the current window.
 19467      At some point, it would be nice to choose between scrollbars
 19468      which reflect the whole buffer size, with special markers
 19469      indicating narrowing, and scrollbars which reflect only the
 19470      visible region.
 19471 
 19472      Note that mini-buffers sometimes aren't displaying any text.  */
 19473   if (!MINI_WINDOW_P (w)
 19474       || (w == XWINDOW (minibuf_window)
 19475           && NILP (echo_area_buffer[0])))
 19476     {
 19477       struct buffer *buf = XBUFFER (w->contents);
 19478 
 19479       whole = BUF_ZV (buf) - BUF_BEGV (buf);
 19480       start = marker_position (w->start) - BUF_BEGV (buf);
 19481       end = BUF_Z (buf) - w->window_end_pos - BUF_BEGV (buf);
 19482 
 19483       /* If w->window_end_pos cannot be trusted, recompute it "the
 19484          hard way".  But don't bother to be too accurate when
 19485          long-line shortcuts are in effect.  */
 19486       if (!w->window_end_valid && !buf->long_line_optimizations_p)
 19487         {
 19488           struct it it;
 19489           struct text_pos start_pos;
 19490           struct buffer *obuf = current_buffer;
 19491           /* When we display the scroll bar of a mini-window,
 19492              current_buffer is not guaranteed to be the mini-window's
 19493              buffer, see the beginning of redisplay_window.  */
 19494           set_buffer_internal_1 (XBUFFER (w->contents));
 19495           SET_TEXT_POS_FROM_MARKER (start_pos, w->start);
 19496           start_display (&it, w, start_pos);
 19497           move_it_to (&it, -1, it.last_visible_x, window_box_height (w), -1,
 19498                       MOVE_TO_X | MOVE_TO_Y);
 19499           end -= (BUF_Z (buf) - IT_CHARPOS (it)) - w->window_end_pos;
 19500           set_buffer_internal_1 (obuf);
 19501         }
 19502 
 19503       if (end < start)
 19504         end = start;
 19505       if (whole < (end - start))
 19506         whole = end - start;
 19507     }
 19508   else
 19509     start = end = whole = 0;
 19510 
 19511   /* Indicate what this scroll bar ought to be displaying now.  */
 19512   if (FRAME_TERMINAL (XFRAME (w->frame))->set_vertical_scroll_bar_hook)
 19513     (*FRAME_TERMINAL (XFRAME (w->frame))->set_vertical_scroll_bar_hook)
 19514       (w, end - start, whole, start);
 19515 }
 19516 
 19517 
 19518 void
 19519 set_horizontal_scroll_bar (struct window *w)
 19520 {
 19521   int start, end, whole, portion;
 19522 
 19523   if (!MINI_WINDOW_P (w) || EQ (w->horizontal_scroll_bar_type, Qbottom))
 19524     {
 19525       struct buffer *b = XBUFFER (w->contents);
 19526       struct buffer *old_buffer = NULL;
 19527       struct it it;
 19528       struct text_pos startp;
 19529 
 19530       if (b != current_buffer)
 19531         {
 19532           old_buffer = current_buffer;
 19533           set_buffer_internal (b);
 19534         }
 19535 
 19536       SET_TEXT_POS_FROM_MARKER (startp, w->start);
 19537       start_display (&it, w, startp);
 19538       it.last_visible_x = INT_MAX;
 19539       whole = move_it_to (&it, -1, INT_MAX, window_box_height (w), -1,
 19540                           MOVE_TO_X | MOVE_TO_Y);
 19541       /* whole = move_it_to (&it, w->window_end_pos, INT_MAX,
 19542                           window_box_height (w), -1,
 19543                           MOVE_TO_POS | MOVE_TO_X | MOVE_TO_Y); */
 19544 
 19545       start = w->hscroll * FRAME_COLUMN_WIDTH (WINDOW_XFRAME (w));
 19546       end = start + window_box_width (w, TEXT_AREA);
 19547       portion = end - start;
 19548       /* After enlarging a horizontally scrolled window such that it
 19549          gets at least as wide as the text it contains, make sure that
 19550          the thumb doesn't fill the entire scroll bar so we can still
 19551          drag it back to see the entire text.  */
 19552       whole = max (whole, end);
 19553 
 19554       if (it.bidi_p)
 19555         {
 19556           Lisp_Object pdir;
 19557 
 19558           pdir = Fcurrent_bidi_paragraph_direction (Qnil);
 19559           if (EQ (pdir, Qright_to_left))
 19560             {
 19561               start = whole - end;
 19562               end = start + portion;
 19563             }
 19564         }
 19565 
 19566       if (old_buffer)
 19567         set_buffer_internal (old_buffer);
 19568     }
 19569   else
 19570     start = end = whole = portion = 0;
 19571 
 19572   w->hscroll_whole = whole;
 19573 
 19574   /* Indicate what this scroll bar ought to be displaying now.  */
 19575   if (FRAME_TERMINAL (XFRAME (w->frame))->set_horizontal_scroll_bar_hook)
 19576     (*FRAME_TERMINAL (XFRAME (w->frame))->set_horizontal_scroll_bar_hook)
 19577       (w, portion, whole, start);
 19578 }
 19579 
 19580 /* Subroutine of redisplay_window, to determine whether a window-start
 19581    point STARTP of WINDOW should be rejected.  */
 19582 static bool
 19583 window_start_acceptable_p (Lisp_Object window, ptrdiff_t startp)
 19584 {
 19585   if (!make_window_start_visible)
 19586     return true;
 19587 
 19588   struct window *w = XWINDOW (window);
 19589   struct frame *f = XFRAME (w->frame);
 19590   Lisp_Object startpos = make_fixnum (startp);
 19591   Lisp_Object invprop, disp_spec;
 19592   struct text_pos ignored;
 19593 
 19594   /* Is STARTP in invisible text?  */
 19595   if ((invprop = Fget_char_property (startpos, Qinvisible, window)),
 19596       TEXT_PROP_MEANS_INVISIBLE (invprop) != 0)
 19597     return false;
 19598 
 19599   /* Is STARTP covered by a replacing 'display' property?  */
 19600   if (!NILP (disp_spec = Fget_char_property (startpos, Qdisplay, window))
 19601       && handle_display_spec (NULL, disp_spec, Qnil, Qnil, &ignored, startp,
 19602                               FRAME_WINDOW_P (f)) > 0)
 19603     return false;
 19604 
 19605   return true;
 19606 }
 19607 
 19608 DEFUN ("long-line-optimizations-p", Flong_line_optimizations_p, Slong_line_optimizations_p,
 19609        0, 0, 0,
 19610        doc: /* Return non-nil if long-line optimizations are in effect in current buffer.
 19611 See `long-line-threshold' and `large-hscroll-threshold' for what these
 19612 optimizations mean and when they are in effect.  */)
 19613   (void)
 19614 {
 19615   return current_buffer->long_line_optimizations_p ? Qt : Qnil;
 19616 }
 19617 
 19618 /* Redisplay leaf window WINDOW.  JUST_THIS_ONE_P means only
 19619    selected_window is redisplayed.
 19620 
 19621    We can return without actually redisplaying the window if fonts has been
 19622    changed on window's frame.  In that case, redisplay_internal will retry.
 19623 
 19624    As one of the important parts of redisplaying a window, we need to
 19625    decide whether the previous window-start position (stored in the
 19626    window's w->start marker position) is still valid, and if it isn't,
 19627    recompute it.  Some details about that:
 19628 
 19629     . The previous window-start could be in a continuation line, in
 19630       which case we need to recompute it when the window width
 19631       changes.  See compute_window_start_on_continuation_line and its
 19632       call below.
 19633 
 19634     . The text that changed since last redisplay could include the
 19635       previous window-start position.  In that case, we try to salvage
 19636       what we can from the current glyph matrix by calling
 19637       try_scrolling, which see.
 19638 
 19639     . Some Emacs command could force us to use a specific window-start
 19640       position by setting the window's force_start flag, or gently
 19641       propose doing that by setting the window's optional_new_start
 19642       flag.  In these cases, we try using the specified start point if
 19643       that succeeds (i.e. the window desired matrix is successfully
 19644       recomputed, and point location is within the window).  In case
 19645       of optional_new_start, we first check if the specified start
 19646       position is feasible, i.e. if it will allow point to be
 19647       displayed in the window.  If using the specified start point
 19648       fails, e.g., if new fonts are needed to be loaded, we abort the
 19649       redisplay cycle and leave it up to the next cycle to figure out
 19650       things.
 19651 
 19652     . Note that the window's force_start flag is sometimes set by
 19653       redisplay itself, when it decides that the previous window start
 19654       point is fine and should be kept.  Search for "goto force_start"
 19655       below to see the details.  Like the values of window-start
 19656       specified outside of redisplay, these internally-deduced values
 19657       are tested for feasibility, and ignored if found to be
 19658       unfeasible.
 19659 
 19660     . Note that the function try_window, used to completely redisplay
 19661       a window, accepts the window's start point as its argument.
 19662       This is used several times in the redisplay code to control
 19663       where the window start will be, according to user options such
 19664       as scroll-conservatively, and also to ensure the screen line
 19665       showing point will be fully (as opposed to partially) visible on
 19666       display.  */
 19667 
 19668 static void
 19669 redisplay_window (Lisp_Object window, bool just_this_one_p)
 19670 {
 19671   struct window *w = XWINDOW (window);
 19672   struct frame *f = XFRAME (w->frame);
 19673   struct buffer *buffer = XBUFFER (w->contents);
 19674   struct buffer *old = current_buffer;
 19675   struct text_pos lpoint, opoint, startp;
 19676   bool update_mode_line;
 19677   int tem;
 19678   struct it it;
 19679   /* Record it now because it's overwritten.  */
 19680   bool current_matrix_up_to_date_p = false;
 19681   bool used_current_matrix_p = false;
 19682   /* This is less strict than current_matrix_up_to_date_p.
 19683      It indicates that the buffer contents and narrowing are unchanged.  */
 19684   bool buffer_unchanged_p = false;
 19685   bool temp_scroll_step = false;
 19686   specpdl_ref count = SPECPDL_INDEX ();
 19687   int rc;
 19688   int centering_position = -1;
 19689   bool last_line_misfit = false;
 19690   ptrdiff_t beg_unchanged, end_unchanged;
 19691   int frame_line_height, margin;
 19692   bool use_desired_matrix;
 19693   void *itdata = NULL;
 19694 
 19695   SET_TEXT_POS (lpoint, PT, PT_BYTE);
 19696   opoint = lpoint;
 19697 
 19698 #ifdef GLYPH_DEBUG
 19699   *w->desired_matrix->method = 0;
 19700 #endif
 19701 
 19702   if (!just_this_one_p && needs_no_redisplay (w))
 19703     return;
 19704 
 19705   /* Make sure that both W's markers are valid.  */
 19706   eassert (XMARKER (w->start)->buffer == buffer);
 19707   eassert (XMARKER (w->pointm)->buffer == buffer);
 19708 
 19709   reconsider_clip_changes (w);
 19710   frame_line_height = default_line_pixel_height (w);
 19711   margin = window_scroll_margin (w, MARGIN_IN_LINES);
 19712 
 19713 
 19714   /* Has the mode line to be updated?  */
 19715   update_mode_line = (w->update_mode_line
 19716                       || update_mode_lines
 19717                       || buffer->clip_changed
 19718                       || buffer->prevent_redisplay_optimizations_p);
 19719 
 19720   if (!just_this_one_p)
 19721     /* If `just_this_one_p' is set, we apparently set must_be_updated_p more
 19722        cleverly elsewhere.  */
 19723     w->must_be_updated_p = true;
 19724 
 19725   if (MINI_WINDOW_P (w))
 19726     {
 19727       if (w == XWINDOW (echo_area_window)
 19728           && !NILP (echo_area_buffer[0]))
 19729         {
 19730           if (update_mode_line)
 19731             /* We may have to update a tty frame's menu bar or a
 19732                tool-bar.  Example `M-x C-h C-h C-g'.  */
 19733             goto finish_menu_bars;
 19734           else
 19735             /* We've already displayed the echo area glyphs in this window.  */
 19736             goto finish_scroll_bars;
 19737         }
 19738       else if ((w != XWINDOW (minibuf_window)
 19739                 || minibuf_level == 0)
 19740                /* When buffer is nonempty, redisplay window normally.  */
 19741                && BUF_Z (XBUFFER (w->contents)) == BUF_BEG (XBUFFER (w->contents))
 19742                /* Quail displays non-mini buffers in minibuffer window.
 19743                   In that case, redisplay the window normally.  */
 19744                && !NILP (Fmemq (w->contents, Vminibuffer_list)))
 19745         {
 19746           /* W is a mini-buffer window, but it's not active, so clear
 19747              it.  */
 19748           int yb = window_text_bottom_y (w);
 19749           struct glyph_row *row;
 19750           int y;
 19751 
 19752           for (y = 0, row = w->desired_matrix->rows;
 19753                y < yb;
 19754                y += row->height, ++row)
 19755             blank_row (w, row, y);
 19756           goto finish_scroll_bars;
 19757         }
 19758       else if (minibuf_level >= 1)
 19759         {
 19760           /* We could have a message produced by set-minibuffer-message
 19761              displayed in the mini-window as an overlay, so resize the
 19762              mini-window if needed.  */
 19763           resize_mini_window (w, false);
 19764         }
 19765 
 19766       clear_glyph_matrix (w->desired_matrix);
 19767     }
 19768 
 19769   /* Otherwise set up data on this window; select its buffer and point
 19770      value.  */
 19771   /* Really select the buffer, for the sake of buffer-local
 19772      variables.  */
 19773   set_buffer_internal_1 (XBUFFER (w->contents));
 19774 
 19775   current_matrix_up_to_date_p
 19776     = (w->window_end_valid
 19777        && !current_buffer->clip_changed
 19778        && !current_buffer->prevent_redisplay_optimizations_p
 19779        && !window_outdated (w)
 19780        && !composition_break_at_point
 19781        && !hscrolling_current_line_p (w));
 19782 
 19783   beg_unchanged = BEG_UNCHANGED;
 19784   end_unchanged = END_UNCHANGED;
 19785 
 19786   SET_TEXT_POS (opoint, PT, PT_BYTE);
 19787 
 19788   specbind (Qinhibit_point_motion_hooks, Qt);
 19789 
 19790   buffer_unchanged_p
 19791     = (w->window_end_valid
 19792        && !current_buffer->clip_changed
 19793        && !window_outdated (w));
 19794 
 19795   /* When windows_or_buffers_changed is non-zero, we can't rely
 19796      on the window end being valid, so set it to zero there.  */
 19797   if (windows_or_buffers_changed)
 19798     {
 19799       /* If window starts on a continuation line, maybe adjust the
 19800          window start in case the window's width changed.  */
 19801       if (XMARKER (w->start)->buffer == current_buffer)
 19802         compute_window_start_on_continuation_line (w);
 19803 
 19804       w->window_end_valid = false;
 19805       /* If so, we also can't rely on current matrix
 19806          and should not fool try_cursor_movement below.  */
 19807       current_matrix_up_to_date_p = false;
 19808     }
 19809 
 19810   /* Some sanity checks.  */
 19811   CHECK_WINDOW_END (w);
 19812   if (Z == Z_BYTE && CHARPOS (opoint) != BYTEPOS (opoint))
 19813     emacs_abort ();
 19814   if (BYTEPOS (opoint) < CHARPOS (opoint))
 19815     emacs_abort ();
 19816 
 19817   if (mode_line_update_needed (w))
 19818     update_mode_line = true;
 19819 
 19820   /* Point refers normally to the selected window.  For any other
 19821      window, set up appropriate value.  */
 19822   if (!EQ (window, selected_window))
 19823     {
 19824       ptrdiff_t new_pt = marker_position (w->pointm);
 19825       ptrdiff_t new_pt_byte = marker_byte_position (w->pointm);
 19826 
 19827       if (new_pt < BEGV)
 19828         {
 19829           new_pt = BEGV;
 19830           new_pt_byte = BEGV_BYTE;
 19831           set_marker_both (w->pointm, Qnil, BEGV, BEGV_BYTE);
 19832         }
 19833       else if (new_pt > (ZV - 1))
 19834         {
 19835           new_pt = ZV;
 19836           new_pt_byte = ZV_BYTE;
 19837           set_marker_both (w->pointm, Qnil, ZV, ZV_BYTE);
 19838         }
 19839 
 19840       /* We don't use SET_PT so that the point-motion hooks don't run.  */
 19841       TEMP_SET_PT_BOTH (new_pt, new_pt_byte);
 19842     }
 19843 
 19844   /* If any of the character widths specified in the display table
 19845      have changed, invalidate the width run cache.  It's true that
 19846      this may be a bit late to catch such changes, but the rest of
 19847      redisplay goes (non-fatally) haywire when the display table is
 19848      changed, so why should we worry about doing any better?  */
 19849   if (current_buffer->width_run_cache
 19850       || (current_buffer->base_buffer
 19851           && current_buffer->base_buffer->width_run_cache))
 19852     {
 19853       struct Lisp_Char_Table *disptab = buffer_display_table ();
 19854 
 19855       if (! disptab_matches_widthtab
 19856           (disptab, XVECTOR (BVAR (current_buffer, width_table))))
 19857         {
 19858           struct buffer *buf = current_buffer;
 19859 
 19860           if (buf->base_buffer)
 19861             buf = buf->base_buffer;
 19862           invalidate_region_cache (buf, buf->width_run_cache, BEG, Z);
 19863           recompute_width_table (current_buffer, disptab);
 19864         }
 19865     }
 19866 
 19867   /* Check whether the buffer to be displayed contains long lines.  */
 19868   if (!NILP (Vlong_line_threshold)
 19869       && !current_buffer->long_line_optimizations_p
 19870       && (CHARS_MODIFF - UNCHANGED_MODIFIED > 8
 19871           || current_buffer->clip_changed))
 19872     {
 19873       ptrdiff_t cur, next, found, max = 0, threshold;
 19874       threshold = XFIXNUM (Vlong_line_threshold);
 19875       for (cur = BEGV; cur < ZV; cur = next)
 19876         {
 19877           next = find_newline1 (cur, CHAR_TO_BYTE (cur), 0, -1, 1,
 19878                                 &found, NULL, true);
 19879           if (next - cur > max) max = next - cur;
 19880           if (!found || max > threshold) break;
 19881         }
 19882       if (max > threshold)
 19883         current_buffer->long_line_optimizations_p = true;
 19884     }
 19885 
 19886   /* If window-start is screwed up, choose a new one.  */
 19887   if (XMARKER (w->start)->buffer != current_buffer)
 19888     goto recenter;
 19889 
 19890   SET_TEXT_POS_FROM_MARKER (startp, w->start);
 19891 
 19892   /* If someone specified a new starting point but did not insist,
 19893      check whether it can be used.  */
 19894   if ((w->optional_new_start || window_frozen_p (w))
 19895       && CHARPOS (startp) >= BEGV
 19896       && CHARPOS (startp) <= ZV)
 19897     {
 19898       ptrdiff_t it_charpos;
 19899 
 19900       w->optional_new_start = false;
 19901       if (!w->force_start)
 19902         {
 19903           start_display (&it, w, startp);
 19904           move_it_to (&it, PT, 0, it.last_visible_y, -1,
 19905                       MOVE_TO_POS | MOVE_TO_X | MOVE_TO_Y);
 19906           /* Record IT's position now, since line_bottom_y might
 19907              change that.  */
 19908           it_charpos = IT_CHARPOS (it);
 19909           /* Make sure we set the force_start flag only if the cursor
 19910              row will be fully visible.  Otherwise, the code under
 19911              force_start label below will try to move point back into
 19912              view, which is not what the code which sets
 19913              optional_new_start wants.  */
 19914           if (it.current_y == 0 || line_bottom_y (&it) < it.last_visible_y)
 19915             {
 19916               if (it_charpos == PT)
 19917                 w->force_start = true;
 19918               /* IT may overshoot PT if text at PT is invisible.  */
 19919               else if (it_charpos > PT && CHARPOS (startp) <= PT)
 19920                 w->force_start = true;
 19921 #ifdef GLYPH_DEBUG
 19922               if (w->force_start)
 19923                 {
 19924                   if (window_frozen_p (w))
 19925                     debug_method_add (w, "set force_start from frozen window start");
 19926                   else
 19927                     debug_method_add (w, "set force_start from optional_new_start");
 19928                 }
 19929 #endif
 19930             }
 19931         }
 19932     }
 19933 
 19934  force_start:
 19935 
 19936   /* Handle case where place to start displaying has been specified,
 19937      unless the specified location is outside the accessible range.  */
 19938   if (w->force_start)
 19939     {
 19940       /* We set this later on if we have to adjust point.  */
 19941       int new_vpos = -1;
 19942 
 19943       w->force_start = false;
 19944 
 19945       /* The vscroll should be preserved in this case, since
 19946          `pixel-scroll-precision-mode' must continue working normally
 19947          when a mini-window is resized.  (bug#55312) */
 19948       if (!w->preserve_vscroll_p || !window_frozen_p (w))
 19949         w->vscroll = 0;
 19950 
 19951       w->preserve_vscroll_p = false;
 19952       w->window_end_valid = false;
 19953 
 19954       /* Forget any recorded base line for line number display.  */
 19955       if (!buffer_unchanged_p)
 19956         w->base_line_number = 0;
 19957 
 19958       /* Redisplay the mode line.  Select the buffer properly for that.
 19959          Also, run the hook window-scroll-functions
 19960          because we have scrolled.  */
 19961       /* Note, we do this after clearing force_start because
 19962          if there's an error, it is better to forget about force_start
 19963          than to get into an infinite loop calling the hook functions
 19964          and having them get more errors.  */
 19965       if (!update_mode_line
 19966           || ! NILP (Vwindow_scroll_functions))
 19967         {
 19968           update_mode_line = true;
 19969           w->update_mode_line = true;
 19970           startp = run_window_scroll_functions (window, startp);
 19971         }
 19972 
 19973       if (CHARPOS (startp) < BEGV)
 19974         SET_TEXT_POS (startp, BEGV, BEGV_BYTE);
 19975       else if (CHARPOS (startp) > ZV)
 19976         SET_TEXT_POS (startp, ZV, ZV_BYTE);
 19977 
 19978       /* Reject the specified start location if it is invisible, and
 19979          the buffer wants it always visible.  */
 19980       if (!window_start_acceptable_p (window, CHARPOS (startp)))
 19981         goto ignore_start;
 19982 
 19983       /* Redisplay, then check if cursor has been set during the
 19984          redisplay.  Give up if new fonts were loaded.  */
 19985       /* We used to issue a CHECK_MARGINS argument to try_window here,
 19986          but this causes scrolling to fail when point begins inside
 19987          the scroll margin (bug#148) -- cyd  */
 19988       clear_glyph_matrix (w->desired_matrix);
 19989       if (!try_window (window, startp, 0))
 19990         {
 19991           w->force_start = true;
 19992           clear_glyph_matrix (w->desired_matrix);
 19993           goto need_larger_matrices;
 19994         }
 19995 
 19996       if (w->cursor.vpos < 0)
 19997         {
 19998           /* If point does not appear, try to move point so it does
 19999              appear.  The desired matrix has been built above, so we
 20000              can use it here.  First see if point is in invisible
 20001              text, and if so, move it to the first visible buffer
 20002              position past that.  */
 20003           struct glyph_row *r = NULL;
 20004           Lisp_Object invprop =
 20005             get_char_property_and_overlay (make_fixnum (PT), Qinvisible,
 20006                                            Qnil, NULL);
 20007 
 20008           if (TEXT_PROP_MEANS_INVISIBLE (invprop) != 0)
 20009             {
 20010               ptrdiff_t alt_pt;
 20011               Lisp_Object invprop_end =
 20012                 Fnext_single_char_property_change (make_fixnum (PT), Qinvisible,
 20013                                                    Qnil, Qnil);
 20014 
 20015               if (FIXNATP (invprop_end))
 20016                 alt_pt = XFIXNAT (invprop_end);
 20017               else
 20018                 alt_pt = ZV;
 20019               r = row_containing_pos (w, alt_pt, w->desired_matrix->rows,
 20020                                       NULL, 0);
 20021             }
 20022           if (r)
 20023             new_vpos = MATRIX_ROW_BOTTOM_Y (r);
 20024           else  /* Give up and just move to the middle of the window.  */
 20025             new_vpos = window_box_height (w) / 2;
 20026         }
 20027 
 20028       if (!cursor_row_fully_visible_p (w, false, false, false))
 20029         {
 20030           /* Point does appear, but on a line partly visible at end of window.
 20031              Move it back to a fully-visible line.  */
 20032           new_vpos = window_box_height (w);
 20033           /* But if window_box_height suggests a Y coordinate that is
 20034              not less than we already have, that line will clearly not
 20035              be fully visible, so give up and scroll the display.
 20036              This can happen when the default face uses a font whose
 20037              dimensions are different from the frame's default
 20038              font.  */
 20039           if (new_vpos >= w->cursor.y)
 20040             {
 20041               w->cursor.vpos = -1;
 20042               clear_glyph_matrix (w->desired_matrix);
 20043               goto try_to_scroll;
 20044             }
 20045         }
 20046       else if (w->cursor.vpos >= 0)
 20047         {
 20048           /* Some people insist on not letting point enter the scroll
 20049              margin, even though this part handles windows that didn't
 20050              scroll at all.  */
 20051           int pixel_margin = margin * frame_line_height;
 20052           bool tab_line = window_wants_tab_line (w);
 20053           bool header_line = window_wants_header_line (w);
 20054 
 20055           /* Note: We add an extra FRAME_LINE_HEIGHT, because the loop
 20056              below, which finds the row to move point to, advances by
 20057              the Y coordinate of the _next_ row, see the definition of
 20058              MATRIX_ROW_BOTTOM_Y.  */
 20059           if (w->cursor.vpos < margin + tab_line + header_line)
 20060             {
 20061               w->cursor.vpos = -1;
 20062               clear_glyph_matrix (w->desired_matrix);
 20063               goto try_to_scroll;
 20064             }
 20065           else
 20066             {
 20067               int window_height = window_box_height (w);
 20068 
 20069               if (tab_line)
 20070                 window_height += CURRENT_TAB_LINE_HEIGHT (w);
 20071               if (header_line)
 20072                 window_height += CURRENT_HEADER_LINE_HEIGHT (w);
 20073               if (w->cursor.y >= window_height - pixel_margin)
 20074                 {
 20075                   w->cursor.vpos = -1;
 20076                   clear_glyph_matrix (w->desired_matrix);
 20077                   goto try_to_scroll;
 20078                 }
 20079             }
 20080         }
 20081 
 20082       /* If we need to move point for either of the above reasons,
 20083          now actually do it.  */
 20084       if (new_vpos >= 0)
 20085         {
 20086           struct glyph_row *row;
 20087 
 20088           row = MATRIX_FIRST_TEXT_ROW (w->desired_matrix);
 20089           while (MATRIX_ROW_BOTTOM_Y (row) < new_vpos
 20090                  && !row->ends_at_zv_p)
 20091             ++row;
 20092 
 20093           TEMP_SET_PT_BOTH (MATRIX_ROW_START_CHARPOS (row),
 20094                             MATRIX_ROW_START_BYTEPOS (row));
 20095 
 20096           if (w != XWINDOW (selected_window))
 20097             set_marker_both (w->pointm, Qnil, PT, PT_BYTE);
 20098           else if (current_buffer == old)
 20099             SET_TEXT_POS (lpoint, PT, PT_BYTE);
 20100 
 20101           set_cursor_from_row (w, row, w->desired_matrix, 0, 0, 0, 0);
 20102 
 20103           /* Re-run pre-redisplay-function so it can update the region
 20104              according to the new position of point.  */
 20105           /* Other than the cursor, w's redisplay is done so we can set its
 20106              redisplay to false.  Also the buffer's redisplay can be set to
 20107              false, since propagate_buffer_redisplay should have already
 20108              propagated its info to `w' anyway.  */
 20109           w->redisplay = false;
 20110           XBUFFER (w->contents)->text->redisplay = false;
 20111           safe__call1 (true, Vpre_redisplay_function, Fcons (window, Qnil));
 20112 
 20113           if (w->redisplay || XBUFFER (w->contents)->text->redisplay
 20114               || ((EQ (Vdisplay_line_numbers, Qrelative)
 20115                    || EQ (Vdisplay_line_numbers, Qvisual))
 20116                   && row != MATRIX_FIRST_TEXT_ROW (w->desired_matrix)))
 20117             {
 20118               /* Either pre-redisplay-function made changes (e.g. move
 20119                  the region), or we moved point in a window that is
 20120                  under display-line-numbers = relative mode.  We need
 20121                  another round of redisplay.  */
 20122               clear_glyph_matrix (w->desired_matrix);
 20123               if (!try_window (window, startp, 0))
 20124                 goto need_larger_matrices;
 20125             }
 20126         }
 20127       if (w->cursor.vpos < 0
 20128           || !cursor_row_fully_visible_p (w, false, false, false))
 20129         {
 20130           clear_glyph_matrix (w->desired_matrix);
 20131           goto try_to_scroll;
 20132         }
 20133 
 20134 #ifdef GLYPH_DEBUG
 20135       debug_method_add (w, "forced window start");
 20136 #endif
 20137       goto done;
 20138     }
 20139 
 20140  ignore_start:
 20141 
 20142   /* Handle case where text has not changed, only point, and it has
 20143      not moved off the frame, and we are not retrying after hscroll.
 20144      (current_matrix_up_to_date_p is true when retrying.)  */
 20145   if (current_matrix_up_to_date_p
 20146       && (rc = try_cursor_movement (window, startp, &temp_scroll_step),
 20147           rc != CURSOR_MOVEMENT_CANNOT_BE_USED))
 20148     {
 20149       switch (rc)
 20150         {
 20151         case CURSOR_MOVEMENT_SUCCESS:
 20152           used_current_matrix_p = true;
 20153           goto done;
 20154 
 20155         case CURSOR_MOVEMENT_MUST_SCROLL:
 20156           goto try_to_scroll;
 20157 
 20158         default:
 20159           emacs_abort ();
 20160         }
 20161     }
 20162   /* If current starting point was originally the beginning of a line
 20163      but no longer is, or if the starting point is invisible but the
 20164      buffer wants it always visible, find a new starting point.  */
 20165   else if (w->start_at_line_beg
 20166            && ((CHARPOS (startp) > BEGV
 20167                 && FETCH_BYTE (BYTEPOS (startp) - 1) != '\n')
 20168                || (CHARPOS (startp) >= BEGV
 20169                    && CHARPOS (startp) <= ZV
 20170                    && !window_start_acceptable_p (window, CHARPOS (startp)))))
 20171     {
 20172 #ifdef GLYPH_DEBUG
 20173       debug_method_add (w, "recenter 1");
 20174 #endif
 20175       goto recenter;
 20176     }
 20177 
 20178   /* Try scrolling with try_window_id.  Value is > 0 if update has
 20179      been done, it is -1 if we know that the same window start will
 20180      not work.  It is 0 if unsuccessful for some other reason.  */
 20181   else if ((tem = try_window_id (w)) != 0)
 20182     {
 20183 #ifdef GLYPH_DEBUG
 20184       debug_method_add (w, "try_window_id %d", tem);
 20185 #endif
 20186 
 20187       if (f->fonts_changed)
 20188         goto need_larger_matrices;
 20189       if (tem > 0)
 20190         goto done;
 20191 
 20192       /* Otherwise try_window_id has returned -1 which means that we
 20193          don't want the alternative below this comment to execute.  */
 20194     }
 20195   else if (CHARPOS (startp) >= BEGV
 20196            && CHARPOS (startp) <= ZV
 20197            && PT >= CHARPOS (startp)
 20198            && (CHARPOS (startp) < ZV
 20199                /* Avoid starting at end of buffer.  */
 20200                || CHARPOS (startp) == BEGV
 20201                || !window_outdated (w)))
 20202     {
 20203       int d1, d2, d5, d6;
 20204       int rtop, rbot;
 20205 
 20206       /* If first window line is a continuation line, and window start
 20207          is inside the modified region, but the first change is before
 20208          current window start, we must select a new window start.
 20209 
 20210          However, if this is the result of a down-mouse event (e.g. by
 20211          extending the mouse-drag-overlay), we don't want to select a
 20212          new window start, since that would change the position under
 20213          the mouse, resulting in an unwanted mouse-movement rather
 20214          than a simple mouse-click.  */
 20215       if (!w->start_at_line_beg
 20216           && NILP (track_mouse)
 20217           && CHARPOS (startp) > BEGV
 20218           && CHARPOS (startp) > BEG + beg_unchanged
 20219           && CHARPOS (startp) <= Z - end_unchanged
 20220           /* Even if w->start_at_line_beg is nil, a new window may
 20221              start at a line_beg, since that's how set_buffer_window
 20222              sets it.  So, we need to check the return value of
 20223              compute_window_start_on_continuation_line.  (See also
 20224              bug#197).  */
 20225           && XMARKER (w->start)->buffer == current_buffer
 20226           && compute_window_start_on_continuation_line (w)
 20227           /* It doesn't make sense to force the window start like we
 20228              do at label force_start if it is already known that point
 20229              will not be fully visible in the resulting window, because
 20230              doing so will move point from its correct position
 20231              instead of scrolling the window to bring point into view.
 20232              See bug#9324.  */
 20233           && pos_visible_p (w, PT, &d1, &d2, &rtop, &rbot, &d5, &d6)
 20234           /* A very tall row could need more than the window height,
 20235              in which case we accept that it is partially visible.  */
 20236           && (rtop != 0) == (rbot != 0))
 20237         {
 20238           w->force_start = true;
 20239           SET_TEXT_POS_FROM_MARKER (startp, w->start);
 20240 #ifdef GLYPH_DEBUG
 20241           debug_method_add (w, "recomputed window start in continuation line");
 20242 #endif
 20243           goto force_start;
 20244         }
 20245 
 20246       /* Don't use the same window-start if it is invisible or covered
 20247          by a replacing 'display' property and the buffer requested
 20248          the window-start to be always visible.  */
 20249       if (!window_start_acceptable_p (window, CHARPOS (startp)))
 20250         {
 20251 #ifdef GLYPH_DEBUG
 20252           debug_method_add (w, "recenter 2");
 20253 #endif
 20254           goto recenter;
 20255         }
 20256 
 20257 #ifdef GLYPH_DEBUG
 20258       debug_method_add (w, "same window start");
 20259 #endif
 20260 
 20261       /* Try to redisplay starting at same place as before.
 20262          If point has not moved off frame, accept the results.  */
 20263       if (!current_matrix_up_to_date_p
 20264           /* Don't use try_window_reusing_current_matrix in this case
 20265              because a window scroll function can have changed the
 20266              buffer.  */
 20267           || !NILP (Vwindow_scroll_functions)
 20268           || MINI_WINDOW_P (w)
 20269           || !(used_current_matrix_p
 20270                = try_window_reusing_current_matrix (w)))
 20271         {
 20272           IF_DEBUG (debug_method_add (w, "1"));
 20273           clear_glyph_matrix (w->desired_matrix);
 20274           if (try_window (window, startp, TRY_WINDOW_CHECK_MARGINS) < 0)
 20275             /* -1 means we need to scroll.
 20276                0 means we need new matrices, but fonts_changed
 20277                is set in that case, so we will detect it below.  */
 20278             goto try_to_scroll;
 20279         }
 20280 
 20281       if (f->fonts_changed)
 20282         goto need_larger_matrices;
 20283 
 20284       if (w->cursor.vpos >= 0)
 20285         {
 20286           if (!just_this_one_p
 20287               || current_buffer->clip_changed
 20288               || BEG_UNCHANGED < CHARPOS (startp))
 20289             /* Forget any recorded base line for line number display.  */
 20290             w->base_line_number = 0;
 20291 
 20292           if (!cursor_row_fully_visible_p (w, true, false, false))
 20293             {
 20294               clear_glyph_matrix (w->desired_matrix);
 20295               last_line_misfit = true;
 20296             }
 20297             /* Drop through and scroll.  */
 20298           else
 20299             goto done;
 20300         }
 20301       else
 20302         clear_glyph_matrix (w->desired_matrix);
 20303     }
 20304 
 20305  try_to_scroll:
 20306 
 20307   /* Redisplay the mode line.  Select the buffer properly for that.  */
 20308   if (!update_mode_line)
 20309     {
 20310       update_mode_line = true;
 20311       w->update_mode_line = true;
 20312     }
 20313 
 20314   /* Try to scroll by specified few lines.  */
 20315   if ((0 < scroll_conservatively
 20316        /* FIXME: the option is supposed to affect minibuffers, but we
 20317           test MINI_WINDOW_P, which can also catch uses of
 20318           mini-windows for displaying the echo area.  Do we need to
 20319           distinguish these two use cases?  */
 20320        || (scroll_minibuffer_conservatively && MINI_WINDOW_P (w))
 20321        || 0 < emacs_scroll_step
 20322        || temp_scroll_step
 20323        || NUMBERP (BVAR (current_buffer, scroll_up_aggressively))
 20324        || NUMBERP (BVAR (current_buffer, scroll_down_aggressively)))
 20325       && CHARPOS (startp) >= BEGV
 20326       && CHARPOS (startp) <= ZV)
 20327     {
 20328       /* The function returns -1 if new fonts were loaded, 1 if
 20329          successful, 0 if not successful.  */
 20330       int ss = try_scrolling (window, just_this_one_p,
 20331                               ((scroll_minibuffer_conservatively
 20332                                 && MINI_WINDOW_P (w))
 20333                                ? SCROLL_LIMIT + 1
 20334                                : scroll_conservatively),
 20335                               emacs_scroll_step,
 20336                               temp_scroll_step, last_line_misfit);
 20337       switch (ss)
 20338         {
 20339         case SCROLLING_SUCCESS:
 20340           goto done;
 20341 
 20342         case SCROLLING_NEED_LARGER_MATRICES:
 20343           goto need_larger_matrices;
 20344 
 20345         case SCROLLING_FAILED:
 20346           break;
 20347 
 20348         default:
 20349           emacs_abort ();
 20350         }
 20351     }
 20352 
 20353   /* Finally, just choose a place to start which positions point
 20354      according to user preferences.  */
 20355 
 20356  recenter:
 20357 
 20358 #ifdef GLYPH_DEBUG
 20359   debug_method_add (w, "recenter");
 20360 #endif
 20361 
 20362   /* Forget any previously recorded base line for line number display.  */
 20363   if (!buffer_unchanged_p)
 20364     w->base_line_number = 0;
 20365 
 20366   /* Determine the window start relative to point.  */
 20367   init_iterator (&it, w, PT, PT_BYTE, NULL, DEFAULT_FACE_ID);
 20368   it.current_y = it.last_visible_y;
 20369   if (centering_position < 0)
 20370     {
 20371       ptrdiff_t margin_pos = CHARPOS (startp);
 20372       Lisp_Object aggressive;
 20373       bool scrolling_up;
 20374 
 20375       /* If there is a scroll margin at the top of the window, find
 20376          its character position.  */
 20377       if (margin
 20378           /* Cannot call start_display if startp is not in the
 20379              accessible region of the buffer.  This can happen when we
 20380              have just switched to a different buffer and/or changed
 20381              its restriction.  In that case, startp is initialized to
 20382              the character position 1 (BEGV) because we did not yet
 20383              have chance to display the buffer even once.  */
 20384           && BEGV <= CHARPOS (startp) && CHARPOS (startp) <= ZV)
 20385         {
 20386           struct it it1;
 20387           void *it1data = NULL;
 20388 
 20389           SAVE_IT (it1, it, it1data);
 20390           start_display (&it1, w, startp);
 20391           move_it_vertically (&it1, margin * frame_line_height);
 20392           margin_pos = IT_CHARPOS (it1);
 20393           RESTORE_IT (&it, &it, it1data);
 20394         }
 20395       scrolling_up = PT > margin_pos;
 20396       aggressive =
 20397         scrolling_up
 20398         ? BVAR (current_buffer, scroll_up_aggressively)
 20399         : BVAR (current_buffer, scroll_down_aggressively);
 20400 
 20401       if (!MINI_WINDOW_P (w)
 20402           && (scroll_conservatively > SCROLL_LIMIT || NUMBERP (aggressive)))
 20403         {
 20404           int pt_offset = 0;
 20405 
 20406           /* Setting scroll-conservatively overrides
 20407              scroll-*-aggressively.  */
 20408           if (!scroll_conservatively && NUMBERP (aggressive))
 20409             {
 20410               double float_amount = XFLOATINT (aggressive);
 20411 
 20412               pt_offset = float_amount * WINDOW_BOX_TEXT_HEIGHT (w);
 20413               if (pt_offset == 0 && float_amount > 0)
 20414                 pt_offset = 1;
 20415               if (pt_offset && margin > 0)
 20416                 margin -= 1;
 20417             }
 20418           /* Compute how much to move the window start backward from
 20419              point so that point will be displayed where the user
 20420              wants it.  */
 20421           if (scrolling_up)
 20422             {
 20423               centering_position = it.last_visible_y;
 20424               if (pt_offset)
 20425                 centering_position -= pt_offset;
 20426               centering_position -=
 20427                 (frame_line_height * (1 + margin + last_line_misfit)
 20428                  + WINDOW_TAB_LINE_HEIGHT (w) + WINDOW_HEADER_LINE_HEIGHT (w));
 20429               /* Don't let point enter the scroll margin near top of
 20430                  the window.  */
 20431               if (centering_position < margin * frame_line_height)
 20432                 centering_position = margin * frame_line_height;
 20433             }
 20434           else
 20435             centering_position = margin * frame_line_height + pt_offset;
 20436         }
 20437       else
 20438         /* Set the window start half the height of the window backward
 20439            from point.  */
 20440         centering_position = window_box_height (w) / 2;
 20441     }
 20442   if (current_buffer->long_line_optimizations_p
 20443       && it.line_wrap == TRUNCATE)
 20444     {
 20445       /* For very long and truncated lines, go back using a simplified
 20446          method, which ignored any inaccuracies due to line-height
 20447          differences, display properties/overlays, etc.  */
 20448       int nlines = centering_position / frame_line_height;
 20449 
 20450       while (nlines-- && IT_CHARPOS (it) > BEGV)
 20451         back_to_previous_visible_line_start (&it);
 20452       reseat_1 (&it, it.current.pos, true);
 20453     }
 20454   else
 20455     move_it_vertically_backward (&it, centering_position);
 20456 
 20457   eassert (IT_CHARPOS (it) >= BEGV);
 20458 
 20459   /* The function move_it_vertically_backward may move over more
 20460      than the specified y-distance.  If it->w is small, e.g. a
 20461      mini-buffer window, we may end up in front of the window's
 20462      display area.  Start displaying at the start of the line
 20463      containing PT in this case.  */
 20464   if (it.current_y <= 0)
 20465     {
 20466       init_iterator (&it, w, PT, PT_BYTE, NULL, DEFAULT_FACE_ID);
 20467       move_it_vertically_backward (&it, 0);
 20468       it.current_y = 0;
 20469     }
 20470 
 20471   it.current_x = it.hpos = 0;
 20472 
 20473   /* Set the window start position here explicitly, to avoid an
 20474      infinite loop in case the functions in window-scroll-functions
 20475      get errors.  */
 20476   set_marker_both (w->start, Qnil, IT_CHARPOS (it), IT_BYTEPOS (it));
 20477 
 20478   /* Run scroll hooks.  */
 20479   startp = run_window_scroll_functions (window, it.current.pos);
 20480 
 20481   /* We invoke try_window and try_window_reusing_current_matrix below,
 20482      and they manipulate the bidi cache.  Save and restore the cache
 20483      state of our iterator, so we could continue using it after that.  */
 20484   itdata = bidi_shelve_cache ();
 20485 
 20486   /* Redisplay the window.  */
 20487   use_desired_matrix = false;
 20488   if (!current_matrix_up_to_date_p
 20489       || windows_or_buffers_changed
 20490       || f->cursor_type_changed
 20491       /* Don't use try_window_reusing_current_matrix in this case
 20492          because it can have changed the buffer.  */
 20493       || !NILP (Vwindow_scroll_functions)
 20494       || !just_this_one_p
 20495       || MINI_WINDOW_P (w)
 20496       || !(used_current_matrix_p
 20497            = try_window_reusing_current_matrix (w)))
 20498     use_desired_matrix = (try_window (window, startp, 0) == 1);
 20499 
 20500   bidi_unshelve_cache (itdata, false);
 20501 
 20502   /* If new fonts have been loaded (due to fontsets), give up.  We
 20503      have to start a new redisplay since we need to re-adjust glyph
 20504      matrices.  */
 20505   if (f->fonts_changed)
 20506     goto need_larger_matrices;
 20507 
 20508   /* If cursor did not appear assume that the middle of the window is
 20509      in the first line of the window.  Do it again with the next line.
 20510      (Imagine a window of height 100, displaying two lines of height
 20511      60.  Moving back 50 from it->last_visible_y will end in the first
 20512      line.)  */
 20513   if (w->cursor.vpos < 0)
 20514     {
 20515       if (w->window_end_valid && PT >= Z - w->window_end_pos)
 20516         {
 20517           clear_glyph_matrix (w->desired_matrix);
 20518           move_it_by_lines (&it, 1);
 20519           try_window (window, it.current.pos, 0);
 20520         }
 20521       else if (PT < IT_CHARPOS (it))
 20522         {
 20523           clear_glyph_matrix (w->desired_matrix);
 20524           move_it_by_lines (&it, -1);
 20525           try_window (window, it.current.pos, 0);
 20526         }
 20527       else if (scroll_conservatively > SCROLL_LIMIT
 20528                && (it.method == GET_FROM_STRING
 20529                    || overlay_touches_p (IT_CHARPOS (it)))
 20530                && IT_CHARPOS (it) < ZV)
 20531         {
 20532           /* If the window starts with a before-string that spans more
 20533              than one screen line, using that position to display the
 20534              window might fail to bring point into the view, because
 20535              start_display will always start by displaying the string,
 20536              whereas the code above determines where to set w->start
 20537              by the buffer position of the place where it takes screen
 20538              coordinates.  Try to recover by finding the next screen
 20539              line that displays buffer text.  */
 20540           ptrdiff_t pos0 = IT_CHARPOS (it);
 20541 
 20542           clear_glyph_matrix (w->desired_matrix);
 20543           do {
 20544             move_it_by_lines (&it, 1);
 20545           } while (IT_CHARPOS (it) == pos0);
 20546           try_window (window, it.current.pos, 0);
 20547         }
 20548       else
 20549         {
 20550           /* Not much we can do about it.  */
 20551         }
 20552     }
 20553 
 20554   /* Consider the following case: Window starts at BEGV, there is
 20555      invisible, intangible text at BEGV, so that display starts at
 20556      some point START > BEGV.  It can happen that we are called with
 20557      PT somewhere between BEGV and START.  Try to handle that case,
 20558      and similar ones.  */
 20559   if (w->cursor.vpos < 0)
 20560     {
 20561       /* Prefer the desired matrix to the current matrix, if possible,
 20562          in the fallback calculations below.  This is because using
 20563          the current matrix might completely goof, e.g. if its first
 20564          row is after point.  */
 20565       struct glyph_matrix *matrix =
 20566         use_desired_matrix ? w->desired_matrix : w->current_matrix;
 20567       /* First, try locating the proper glyph row for PT.  */
 20568       struct glyph_row *row =
 20569         row_containing_pos (w, PT, matrix->rows, NULL, 0);
 20570 
 20571       /* Sometimes point is at the beginning of invisible text that is
 20572          before the 1st character displayed in the row.  In that case,
 20573          row_containing_pos fails to find the row, because no glyphs
 20574          with appropriate buffer positions are present in the row.
 20575          Therefore, we next try to find the row which shows the 1st
 20576          position after the invisible text.  */
 20577       if (!row)
 20578         {
 20579           Lisp_Object val =
 20580             get_char_property_and_overlay (make_fixnum (PT), Qinvisible,
 20581                                            Qnil, NULL);
 20582 
 20583           if (TEXT_PROP_MEANS_INVISIBLE (val) != 0)
 20584             {
 20585               ptrdiff_t alt_pos;
 20586               Lisp_Object invis_end =
 20587                 Fnext_single_char_property_change (make_fixnum (PT), Qinvisible,
 20588                                                    Qnil, Qnil);
 20589 
 20590               if (FIXNATP (invis_end))
 20591                 alt_pos = XFIXNAT (invis_end);
 20592               else
 20593                 alt_pos = ZV;
 20594               row = row_containing_pos (w, alt_pos, matrix->rows, NULL, 0);
 20595             }
 20596         }
 20597       /* Finally, fall back on the first row of the window after the
 20598          tab-line and header line (if any).  This is slightly better
 20599          than not displaying the cursor at all.  */
 20600       if (!row)
 20601         {
 20602           row = matrix->rows;
 20603           /* Skip the tab-line and header-line rows, if any.  */
 20604           if (row->tab_line_p)
 20605             ++row;
 20606           if (row->mode_line_p)
 20607             ++row;
 20608         }
 20609       set_cursor_from_row (w, row, matrix, 0, 0, 0, 0);
 20610     }
 20611 
 20612   if (!cursor_row_fully_visible_p (w, false, false, false))
 20613     {
 20614       /* If vscroll is enabled, disable it and try again.  */
 20615       if (w->vscroll)
 20616         {
 20617           w->vscroll = 0;
 20618           clear_glyph_matrix (w->desired_matrix);
 20619           goto recenter;
 20620         }
 20621 
 20622       /* Users who set scroll-conservatively to a large number want
 20623          point just above/below the scroll margin.  If we ended up
 20624          with point's row partially visible, move the window start to
 20625          make that row fully visible and out of the margin.  */
 20626       if (scroll_conservatively > SCROLL_LIMIT)
 20627         {
 20628           int window_total_lines
 20629             = WINDOW_TOTAL_LINES (w) * FRAME_LINE_HEIGHT (f) / frame_line_height;
 20630           bool move_down = w->cursor.vpos >= window_total_lines / 2;
 20631 
 20632           move_it_by_lines (&it, move_down ? margin + 1 : -(margin + 1));
 20633           clear_glyph_matrix (w->desired_matrix);
 20634           if (1 == try_window (window, it.current.pos,
 20635                                TRY_WINDOW_CHECK_MARGINS))
 20636             goto done;
 20637         }
 20638 
 20639       /* If centering point failed to make the whole line visible,
 20640          put point at the top instead.  That has to make the whole line
 20641          visible, if it can be done.  */
 20642       if (centering_position == 0)
 20643         goto done;
 20644 
 20645       clear_glyph_matrix (w->desired_matrix);
 20646       centering_position = 0;
 20647       goto recenter;
 20648     }
 20649 
 20650  done:
 20651 
 20652   SET_TEXT_POS_FROM_MARKER (startp, w->start);
 20653   w->start_at_line_beg = (CHARPOS (startp) == BEGV
 20654                           || FETCH_BYTE (BYTEPOS (startp) - 1) == '\n');
 20655 
 20656   /* Display the mode line, header line, and tab-line, if we must.  */
 20657   if ((update_mode_line
 20658        /* If window not full width, must redo its mode line
 20659           if (a) the window to its side is being redone and
 20660           (b) we do a frame-based redisplay.  This is a consequence
 20661           of how inverted lines are drawn in frame-based redisplay.  */
 20662        || (!just_this_one_p
 20663            && !FRAME_WINDOW_P (f)
 20664            && !WINDOW_FULL_WIDTH_P (w))
 20665        /* Line number to display.  */
 20666        || w->base_line_pos > 0
 20667        /* Column number is displayed and different from the one displayed.  */
 20668        || (w->column_number_displayed != -1
 20669            && (w->column_number_displayed != current_column ())))
 20670       /* This means that the window has a mode line.  */
 20671       && (window_wants_mode_line (w)
 20672           || window_wants_header_line (w)
 20673           || window_wants_tab_line (w)))
 20674     {
 20675       specpdl_ref count1 = SPECPDL_INDEX ();
 20676 
 20677       specbind (Qinhibit_quit, Qt);
 20678       display_mode_lines (w);
 20679       unbind_to (count1, Qnil);
 20680 
 20681       /* If mode line height has changed, arrange for a thorough
 20682          immediate redisplay using the correct mode line height.  */
 20683       if (window_wants_mode_line (w)
 20684           && CURRENT_MODE_LINE_HEIGHT (w) != DESIRED_MODE_LINE_HEIGHT (w))
 20685         {
 20686           f->fonts_changed = true;
 20687           w->mode_line_height = -1;
 20688           MATRIX_MODE_LINE_ROW (w->current_matrix)->height
 20689             = DESIRED_MODE_LINE_HEIGHT (w);
 20690         }
 20691 
 20692       /* If tab line height has changed, arrange for a thorough
 20693          immediate redisplay using the correct tab line height.  */
 20694       if (window_wants_tab_line (w)
 20695           && CURRENT_TAB_LINE_HEIGHT (w) != DESIRED_TAB_LINE_HEIGHT (w))
 20696         {
 20697           f->fonts_changed = true;
 20698           w->tab_line_height = -1;
 20699           MATRIX_TAB_LINE_ROW (w->current_matrix)->height
 20700             = DESIRED_TAB_LINE_HEIGHT (w);
 20701         }
 20702 
 20703       /* If header line height has changed, arrange for a thorough
 20704          immediate redisplay using the correct header line height.  */
 20705       if (window_wants_header_line (w)
 20706           && CURRENT_HEADER_LINE_HEIGHT (w) != DESIRED_HEADER_LINE_HEIGHT (w))
 20707         {
 20708           f->fonts_changed = true;
 20709           w->header_line_height = -1;
 20710           MATRIX_HEADER_LINE_ROW (w->current_matrix)->height
 20711             = DESIRED_HEADER_LINE_HEIGHT (w);
 20712         }
 20713 
 20714       if (f->fonts_changed)
 20715         goto need_larger_matrices;
 20716     }
 20717 
 20718   if (!line_number_displayed && w->base_line_pos != -1)
 20719     {
 20720       w->base_line_pos = 0;
 20721       w->base_line_number = 0;
 20722     }
 20723 
 20724  finish_menu_bars:
 20725 
 20726   /* When we reach a frame's selected window, redo the frame's menu
 20727      bar, tool bar, tab-bar, and the frame's title.  */
 20728   if (update_mode_line
 20729       && EQ (FRAME_SELECTED_WINDOW (f), window))
 20730     {
 20731       bool redisplay_menu_p;
 20732 
 20733       if (FRAME_WINDOW_P (f))
 20734         {
 20735 #ifdef HAVE_EXT_MENU_BAR
 20736           redisplay_menu_p = FRAME_EXTERNAL_MENU_BAR (f);
 20737 #else
 20738           redisplay_menu_p = FRAME_MENU_BAR_LINES (f) > 0;
 20739 #endif
 20740         }
 20741       else
 20742         redisplay_menu_p = FRAME_MENU_BAR_LINES (f) > 0;
 20743 
 20744       if (redisplay_menu_p)
 20745         display_menu_bar (w);
 20746 
 20747 #ifdef HAVE_WINDOW_SYSTEM
 20748       if (FRAME_WINDOW_P (f))
 20749         {
 20750           if (WINDOWP (f->tab_bar_window)
 20751               && (FRAME_TAB_BAR_LINES (f) > 0
 20752                   || !NILP (Vauto_resize_tab_bars))
 20753               && redisplay_tab_bar (f))
 20754             ignore_mouse_drag_p = true;
 20755 
 20756 #ifdef HAVE_EXT_TOOL_BAR
 20757           if (FRAME_EXTERNAL_TOOL_BAR (f))
 20758             update_frame_tool_bar (f);
 20759 #else
 20760           if (WINDOWP (f->tool_bar_window)
 20761               && (FRAME_TOOL_BAR_LINES (f) > 0
 20762                   || !NILP (Vauto_resize_tool_bars))
 20763               && redisplay_tool_bar (f))
 20764             ignore_mouse_drag_p = true;
 20765 #endif
 20766         }
 20767       else
 20768         {
 20769           if ((FRAME_TAB_BAR_LINES (f) > 0))
 20770             display_tab_bar (w);
 20771         }
 20772 
 20773       gui_consider_frame_title (w->frame);
 20774 #else
 20775       if ((FRAME_TAB_BAR_LINES (f) > 0))
 20776         display_tab_bar (w);
 20777 #endif
 20778     }
 20779 
 20780 #ifdef HAVE_WINDOW_SYSTEM
 20781   if (FRAME_WINDOW_P (f)
 20782       && update_window_fringes (w, (just_this_one_p
 20783                                     || (!used_current_matrix_p && !overlay_arrow_seen)
 20784                                     || w->pseudo_window_p)))
 20785     {
 20786       update_begin (f);
 20787       block_input ();
 20788       if (draw_window_fringes (w, true))
 20789         {
 20790           if (WINDOW_RIGHT_DIVIDER_WIDTH (w))
 20791             gui_draw_right_divider (w);
 20792           else
 20793             gui_draw_vertical_border (w);
 20794         }
 20795       unblock_input ();
 20796       update_end (f);
 20797     }
 20798 
 20799   if (WINDOW_BOTTOM_DIVIDER_WIDTH (w))
 20800     gui_draw_bottom_divider (w);
 20801 #endif /* HAVE_WINDOW_SYSTEM */
 20802 
 20803   /* We go to this label, with fonts_changed set, if it is
 20804      necessary to try again using larger glyph matrices.
 20805      We have to redeem the scroll bar even in this case,
 20806      because the loop in redisplay_internal expects that.  */
 20807  need_larger_matrices:
 20808   ;
 20809  finish_scroll_bars:
 20810 
 20811    if (WINDOW_HAS_VERTICAL_SCROLL_BAR (w) || WINDOW_HAS_HORIZONTAL_SCROLL_BAR (w))
 20812     {
 20813       if (WINDOW_HAS_VERTICAL_SCROLL_BAR (w))
 20814         /* Set the thumb's position and size.  */
 20815         set_vertical_scroll_bar (w);
 20816 
 20817       if (WINDOW_HAS_HORIZONTAL_SCROLL_BAR (w))
 20818         /* Set the thumb's position and size.  */
 20819         set_horizontal_scroll_bar (w);
 20820 
 20821       /* Note that we actually used the scroll bar attached to this
 20822          window, so it shouldn't be deleted at the end of redisplay.  */
 20823       if (FRAME_TERMINAL (f)->redeem_scroll_bar_hook)
 20824         (*FRAME_TERMINAL (f)->redeem_scroll_bar_hook) (w);
 20825     }
 20826 
 20827   /* Restore current_buffer and value of point in it.  The window
 20828      update may have changed the buffer, so first make sure `opoint'
 20829      is still valid (Bug#6177).  */
 20830   if (CHARPOS (opoint) < BEGV)
 20831     TEMP_SET_PT_BOTH (BEGV, BEGV_BYTE);
 20832   else if (CHARPOS (opoint) > ZV)
 20833     TEMP_SET_PT_BOTH (Z, Z_BYTE);
 20834   else
 20835     TEMP_SET_PT_BOTH (CHARPOS (opoint), BYTEPOS (opoint));
 20836 
 20837   set_buffer_internal_1 (old);
 20838   /* Avoid an abort in TEMP_SET_PT_BOTH if the buffer has become
 20839      shorter.  This can be caused by log truncation in *Messages*.  */
 20840   if (CHARPOS (lpoint) <= ZV)
 20841     TEMP_SET_PT_BOTH (CHARPOS (lpoint), BYTEPOS (lpoint));
 20842 
 20843   unbind_to (count, Qnil);
 20844 }
 20845 
 20846 
 20847 /* Build the complete desired matrix of WINDOW with a window start
 20848    buffer position POS.
 20849 
 20850    Value is 1 if successful.  It is zero if fonts were loaded during
 20851    redisplay or the dimensions of the desired matrix were found
 20852    insufficient, which makes re-adjusting glyph matrices necessary.
 20853    Value is -1 if point would appear in the scroll margins.  (We check
 20854    the former only if TRY_WINDOW_IGNORE_FONTS_CHANGE is unset in
 20855    FLAGS, and the latter only if TRY_WINDOW_CHECK_MARGINS is set in
 20856    FLAGS.)
 20857 
 20858    Note that 'x-show-tip' invokes this function in a special way, and
 20859    in that case the return value of zero doesn't necessarily mean the
 20860    glyph matrices need to be re-adjusted, if the entire text of the
 20861    tooltip was processed and has its glyphs in the matrix's glyph
 20862    rows, i.e. if the dimensions of the matrix were found insufficient
 20863    while producing empty glyph rows beyond ZV.  */
 20864 
 20865 int
 20866 try_window (Lisp_Object window, struct text_pos pos, int flags)
 20867 {
 20868   struct window *w = XWINDOW (window);
 20869   struct it it;
 20870   struct glyph_row *last_text_row = NULL;
 20871   struct frame *f = XFRAME (w->frame);
 20872   int cursor_vpos = w->cursor.vpos;
 20873 
 20874   /* Make POS the new window start.  */
 20875   set_marker_both (w->start, Qnil, CHARPOS (pos), BYTEPOS (pos));
 20876 
 20877   /* Mark cursor position as unknown.  No overlay arrow seen.  */
 20878   w->cursor.vpos = -1;
 20879   overlay_arrow_seen = false;
 20880 
 20881   /* Initialize iterator and info to start at POS.  */
 20882   start_display (&it, w, pos);
 20883   it.glyph_row->reversed_p = false;
 20884 
 20885   /* Display all lines of W.  */
 20886   while (it.current_y < it.last_visible_y)
 20887     {
 20888       int last_row_scale = it.w->nrows_scale_factor;
 20889       int last_col_scale = it.w->ncols_scale_factor;
 20890       if (display_line (&it, cursor_vpos))
 20891         last_text_row = it.glyph_row - 1;
 20892       if (f->fonts_changed
 20893           && !((flags & TRY_WINDOW_IGNORE_FONTS_CHANGE)
 20894                /* If the matrix dimensions are insufficient, we _must_
 20895                   fail and let dispnew.c reallocate the matrix.  */
 20896                && last_row_scale == it.w->nrows_scale_factor
 20897                && last_col_scale == it.w->ncols_scale_factor))
 20898         return 0;
 20899     }
 20900 
 20901   /* Save the character position of 'it' before we call
 20902      'start_display' again.  */
 20903   ptrdiff_t it_charpos = IT_CHARPOS (it);
 20904 
 20905   /* Don't let the cursor end in the scroll margins.  However, when
 20906      the window is vscrolled, we leave it to vscroll to handle the
 20907      margins, see window_scroll_pixel_based.  */
 20908   if ((flags & TRY_WINDOW_CHECK_MARGINS)
 20909       && w->vscroll == 0
 20910       && !MINI_WINDOW_P (w))
 20911     {
 20912       int top_scroll_margin = window_scroll_margin (w, MARGIN_IN_PIXELS);
 20913       int bot_scroll_margin = top_scroll_margin;
 20914       if (window_wants_header_line (w))
 20915         top_scroll_margin += CURRENT_HEADER_LINE_HEIGHT (w);
 20916       if (window_wants_tab_line (w))
 20917         top_scroll_margin += CURRENT_TAB_LINE_HEIGHT (w);
 20918       start_display (&it, w, pos);
 20919 
 20920       if ((w->cursor.y >= 0
 20921            && w->cursor.y < top_scroll_margin
 20922            && CHARPOS (pos) > BEGV)
 20923           /* rms: considering make_cursor_line_fully_visible_p here
 20924              seems to give wrong results.  We don't want to recenter
 20925              when the last line is partly visible, we want to allow
 20926              that case to be handled in the usual way.  */
 20927           || w->cursor.y > (it.last_visible_y - partial_line_height (&it)
 20928                             - bot_scroll_margin - 1))
 20929         {
 20930           w->cursor.vpos = -1;
 20931           clear_glyph_matrix (w->desired_matrix);
 20932           return -1;
 20933         }
 20934     }
 20935 
 20936   /* If bottom moved off end of frame, change mode line percentage.  */
 20937   if (w->window_end_pos <= 0 && Z != it_charpos)
 20938     w->update_mode_line = true;
 20939 
 20940   /* Set window_end_pos to the offset of the last character displayed
 20941      on the window from the end of current_buffer.  Set
 20942      window_end_vpos to its row number.  */
 20943   if (last_text_row)
 20944     {
 20945       eassert (MATRIX_ROW_DISPLAYS_TEXT_P (last_text_row));
 20946       adjust_window_ends (w, last_text_row, false);
 20947       eassert
 20948         (MATRIX_ROW_DISPLAYS_TEXT_P (MATRIX_ROW (w->desired_matrix,
 20949                                                  w->window_end_vpos)));
 20950     }
 20951   else
 20952     {
 20953       w->window_end_bytepos = Z_BYTE - ZV_BYTE;
 20954       w->window_end_pos = Z - ZV;
 20955       w->window_end_vpos = 0;
 20956     }
 20957 
 20958   /* But that is not valid info until redisplay finishes.  */
 20959   w->window_end_valid = false;
 20960   return 1;
 20961 }
 20962 
 20963 
 20964 
 20965 /************************************************************************
 20966     Window redisplay reusing current matrix when buffer has not changed
 20967  ************************************************************************/
 20968 
 20969 /* Try redisplay of window W showing an unchanged buffer with a
 20970    different window start than the last time it was displayed by
 20971    reusing its current matrix.  Value is true if successful.
 20972    W->start is the new window start.  */
 20973 
 20974 static bool
 20975 try_window_reusing_current_matrix (struct window *w)
 20976 {
 20977   struct frame *f = XFRAME (w->frame);
 20978   struct glyph_row *bottom_row;
 20979   struct it it;
 20980   struct run run;
 20981   struct text_pos start, new_start;
 20982   int nrows_scrolled, i;
 20983   struct glyph_row *last_text_row;
 20984   struct glyph_row *last_reused_text_row;
 20985   struct glyph_row *start_row;
 20986   int start_vpos, min_y, max_y;
 20987 
 20988 #ifdef GLYPH_DEBUG
 20989   if (inhibit_try_window_reusing)
 20990     return false;
 20991 #endif
 20992 
 20993   if (/* This function doesn't handle terminal frames.  */
 20994       !FRAME_WINDOW_P (f)
 20995       /* Don't try to reuse the display if windows have been split
 20996          or such.  */
 20997       || windows_or_buffers_changed
 20998       || f->cursor_type_changed
 20999       /* This function cannot handle buffers where the overlay arrow
 21000          is shown on the fringes, because if the arrow position
 21001          changes, we cannot just reuse the current matrix.  */
 21002       || overlay_arrow_in_current_buffer_p ())
 21003     return false;
 21004 
 21005   /* Can't do this if showing trailing whitespace.  */
 21006   if (!NILP (Vshow_trailing_whitespace))
 21007     return false;
 21008 
 21009   /* If top-line visibility has changed, give up.  */
 21010   if (window_wants_tab_line (w)
 21011       != MATRIX_TAB_LINE_ROW (w->current_matrix)->mode_line_p)
 21012     return false;
 21013 
 21014   /* If top-line visibility has changed, give up.  */
 21015   if (window_wants_header_line (w)
 21016       != MATRIX_HEADER_LINE_ROW (w->current_matrix)->mode_line_p)
 21017     return false;
 21018 
 21019   /* Give up if old or new display is scrolled vertically.  We could
 21020      make this function handle this, but right now it doesn't.  */
 21021   start_row = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
 21022   if (w->vscroll || MATRIX_ROW_PARTIALLY_VISIBLE_P (w, start_row))
 21023     return false;
 21024 
 21025   /* Clear the desired matrix for the display below.  */
 21026   clear_glyph_matrix (w->desired_matrix);
 21027 
 21028   /* Give up if line numbers are being displayed, because reusing the
 21029      current matrix might use the wrong width for line-number
 21030      display.  */
 21031   if (!NILP (Vdisplay_line_numbers))
 21032     return false;
 21033 
 21034   /* Can't scroll the display of w32 GUI frames when position of point
 21035      is indicated by the system caret, because scrolling the display
 21036      will then "copy" the pixels used by the caret.  */
 21037 #ifdef HAVE_NTGUI
 21038   if (w32_use_visible_system_caret)
 21039     return false;
 21040 #endif
 21041 
 21042   /* The variable new_start now holds the new window start.  The old
 21043      start `start' can be determined from the current matrix.  */
 21044   SET_TEXT_POS_FROM_MARKER (new_start, w->start);
 21045   start = start_row->minpos;
 21046   start_vpos = MATRIX_ROW_VPOS (start_row, w->current_matrix);
 21047 
 21048   if (CHARPOS (new_start) <= CHARPOS (start))
 21049     {
 21050       /* Don't use this method if the display starts with an ellipsis
 21051          displayed for invisible text.  It's not easy to handle that case
 21052          below, and it's certainly not worth the effort since this is
 21053          not a frequent case.  */
 21054       if (in_ellipses_for_invisible_text_p (&start_row->start, w))
 21055         return false;
 21056 
 21057       IF_DEBUG (debug_method_add (w, "twu1"));
 21058 
 21059       /* Display up to a row that can be reused.  The variable
 21060          last_text_row is set to the last row displayed that displays
 21061          text.  Note that it.vpos == 0 if or if not there is a
 21062          header-line; it's not the same as the MATRIX_ROW_VPOS!  */
 21063       start_display (&it, w, new_start);
 21064       w->cursor.vpos = -1;
 21065       last_text_row = last_reused_text_row = NULL;
 21066 
 21067       while (it.current_y < it.last_visible_y && !f->fonts_changed)
 21068         {
 21069           /* If we have reached into the characters in the START row,
 21070              that means the line boundaries have changed.  So we
 21071              can't start copying with the row START.  Maybe it will
 21072              work to start copying with the following row.  */
 21073           while (IT_CHARPOS (it) > CHARPOS (start))
 21074             {
 21075               /* Advance to the next row as the "start".  */
 21076               start_row++;
 21077               start = start_row->minpos;
 21078               /* If there are no more rows to try, or just one, give up.  */
 21079               if (start_row == MATRIX_MODE_LINE_ROW (w->current_matrix) - 1
 21080                   || w->vscroll || MATRIX_ROW_PARTIALLY_VISIBLE_P (w, start_row)
 21081                   || CHARPOS (start) == ZV)
 21082                 {
 21083                   clear_glyph_matrix (w->desired_matrix);
 21084                   return false;
 21085                 }
 21086 
 21087               start_vpos = MATRIX_ROW_VPOS (start_row, w->current_matrix);
 21088             }
 21089           /* If we have reached alignment, we can copy the rest of the
 21090              rows.  */
 21091           if (IT_CHARPOS (it) == CHARPOS (start)
 21092               /* Don't accept "alignment" inside a display vector,
 21093                  since start_row could have started in the middle of
 21094                  that same display vector (thus their character
 21095                  positions match), and we have no way of telling if
 21096                  that is the case.  */
 21097               && it.current.dpvec_index < 0)
 21098             break;
 21099 
 21100           it.glyph_row->reversed_p = false;
 21101           if (display_line (&it, -1))
 21102             last_text_row = it.glyph_row - 1;
 21103 
 21104         }
 21105 
 21106       /* A value of current_y < last_visible_y means that we stopped
 21107          at the previous window start, which in turn means that we
 21108          have at least one reusable row.  */
 21109       if (it.current_y < it.last_visible_y)
 21110         {
 21111           struct glyph_row *row;
 21112 
 21113           /* IT.vpos always starts from 0; it counts text lines.  */
 21114           nrows_scrolled = it.vpos - (start_row - MATRIX_FIRST_TEXT_ROW (w->current_matrix));
 21115 
 21116           /* Find PT if not already found in the lines displayed.  */
 21117           if (w->cursor.vpos < 0)
 21118             {
 21119               int dy = it.current_y - start_row->y;
 21120 
 21121               row = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
 21122               row = row_containing_pos (w, PT, row, NULL, dy);
 21123               if (row)
 21124                 set_cursor_from_row (w, row, w->current_matrix, 0, 0,
 21125                                      dy, nrows_scrolled);
 21126               else
 21127                 {
 21128                   clear_glyph_matrix (w->desired_matrix);
 21129                   return false;
 21130                 }
 21131             }
 21132 
 21133           /* Scroll the display.  Do it before the current matrix is
 21134              changed.  The problem here is that update has not yet
 21135              run, i.e. part of the current matrix is not up to date.
 21136              scroll_run_hook will clear the cursor, and use the
 21137              current matrix to get the height of the row the cursor is
 21138              in.  */
 21139           run.current_y = start_row->y;
 21140           run.desired_y = it.current_y;
 21141           run.height = it.last_visible_y - it.current_y;
 21142 
 21143           if (run.height > 0 && run.current_y != run.desired_y)
 21144             {
 21145 #ifdef HAVE_WINDOW_SYSTEM
 21146               update_begin (f);
 21147               gui_update_window_begin (w);
 21148               FRAME_RIF (f)->clear_window_mouse_face (w);
 21149               FRAME_RIF (f)->scroll_run_hook (w, &run);
 21150               gui_update_window_end (w, false, false);
 21151               update_end (f);
 21152 #endif
 21153             }
 21154 
 21155           /* Shift current matrix down by nrows_scrolled lines.  */
 21156           bottom_row = MATRIX_BOTTOM_TEXT_ROW (w->current_matrix, w);
 21157           rotate_matrix (w->current_matrix,
 21158                          start_vpos,
 21159                          MATRIX_ROW_VPOS (bottom_row, w->current_matrix),
 21160                          nrows_scrolled);
 21161 
 21162           /* Disable lines that must be updated.  */
 21163           for (i = 0; i < nrows_scrolled; ++i)
 21164             (start_row + i)->enabled_p = false;
 21165 
 21166           /* Re-compute Y positions.  */
 21167           min_y = WINDOW_TAB_LINE_HEIGHT (w) + WINDOW_HEADER_LINE_HEIGHT (w);
 21168           max_y = it.last_visible_y;
 21169           for (row = start_row + nrows_scrolled;
 21170                row < bottom_row;
 21171                ++row)
 21172             {
 21173               row->y = it.current_y;
 21174               row->visible_height = row->height;
 21175 
 21176               if (row->y < min_y)
 21177                 row->visible_height -= min_y - row->y;
 21178               if (row->y + row->height > max_y)
 21179                 row->visible_height -= row->y + row->height - max_y;
 21180               if (row->fringe_bitmap_periodic_p)
 21181                 row->redraw_fringe_bitmaps_p = true;
 21182 
 21183               it.current_y += row->height;
 21184 
 21185               if (MATRIX_ROW_DISPLAYS_TEXT_P (row))
 21186                 last_reused_text_row = row;
 21187               if (MATRIX_ROW_BOTTOM_Y (row) >= it.last_visible_y)
 21188                 break;
 21189             }
 21190 
 21191           /* Disable lines in the current matrix which are now
 21192              below the window.  */
 21193           for (++row; row < bottom_row; ++row)
 21194             row->enabled_p = row->mode_line_p = row->tab_line_p = false;
 21195         }
 21196 
 21197       /* Update window_end_pos etc.; last_reused_text_row is the last
 21198          reused row from the current matrix containing text, if any.
 21199          The value of last_text_row is the last displayed line
 21200          containing text.  */
 21201       if (last_reused_text_row)
 21202         adjust_window_ends (w, last_reused_text_row, true);
 21203       else if (last_text_row)
 21204         adjust_window_ends (w, last_text_row, false);
 21205       else
 21206         {
 21207           /* This window must be completely empty.  */
 21208           w->window_end_bytepos = Z_BYTE - ZV_BYTE;
 21209           w->window_end_pos = Z - ZV;
 21210           w->window_end_vpos = 0;
 21211         }
 21212       w->window_end_valid = false;
 21213 
 21214       /* Update hint: don't try scrolling again in update_window.  */
 21215       w->desired_matrix->no_scrolling_p = true;
 21216 
 21217 #ifdef GLYPH_DEBUG
 21218       debug_method_add (w, "try_window_reusing_current_matrix 1");
 21219 #endif
 21220       return true;
 21221     }
 21222   else if (CHARPOS (new_start) > CHARPOS (start))
 21223     {
 21224       struct glyph_row *pt_row, *row;
 21225       struct glyph_row *first_reusable_row;
 21226       struct glyph_row *first_row_to_display;
 21227       int dy;
 21228       int yb = window_text_bottom_y (w);
 21229 
 21230       /* Find the row starting at new_start, if there is one.  Don't
 21231          reuse a partially visible line at the end.  */
 21232       first_reusable_row = start_row;
 21233       while (first_reusable_row->enabled_p
 21234              && MATRIX_ROW_BOTTOM_Y (first_reusable_row) < yb
 21235              && (MATRIX_ROW_START_CHARPOS (first_reusable_row)
 21236                  < CHARPOS (new_start)))
 21237         ++first_reusable_row;
 21238 
 21239       /* Give up if there is no row to reuse.  */
 21240       if (MATRIX_ROW_BOTTOM_Y (first_reusable_row) >= yb
 21241           || !first_reusable_row->enabled_p
 21242           || (MATRIX_ROW_START_CHARPOS (first_reusable_row)
 21243               != CHARPOS (new_start)))
 21244         return false;
 21245 
 21246       /* We can reuse fully visible rows beginning with
 21247          first_reusable_row to the end of the window.  Set
 21248          first_row_to_display to the first row that cannot be reused.
 21249          Set pt_row to the row containing point, if there is any.  */
 21250       pt_row = NULL;
 21251       for (first_row_to_display = first_reusable_row;
 21252            MATRIX_ROW_BOTTOM_Y (first_row_to_display) < yb;
 21253            ++first_row_to_display)
 21254         {
 21255           if (PT >= MATRIX_ROW_START_CHARPOS (first_row_to_display)
 21256               && (PT < MATRIX_ROW_END_CHARPOS (first_row_to_display)
 21257                   || (PT == MATRIX_ROW_END_CHARPOS (first_row_to_display)
 21258                       && first_row_to_display->ends_at_zv_p
 21259                       && pt_row == NULL)))
 21260             pt_row = first_row_to_display;
 21261         }
 21262 
 21263       if (first_row_to_display->y >= yb)
 21264         return false;
 21265 
 21266       /* Start displaying at the start of first_row_to_display.  */
 21267       init_to_row_start (&it, w, first_row_to_display);
 21268 
 21269       nrows_scrolled = (MATRIX_ROW_VPOS (first_reusable_row, w->current_matrix)
 21270                         - start_vpos);
 21271       it.vpos = (MATRIX_ROW_VPOS (first_row_to_display, w->current_matrix)
 21272                  - nrows_scrolled);
 21273       it.current_y = (first_row_to_display->y - first_reusable_row->y
 21274                       + WINDOW_TAB_LINE_HEIGHT (w) + WINDOW_HEADER_LINE_HEIGHT (w));
 21275 
 21276       /* Display lines beginning with first_row_to_display in the
 21277          desired matrix.  Set last_text_row to the last row displayed
 21278          that displays text.  */
 21279       it.glyph_row = MATRIX_ROW (w->desired_matrix, it.vpos);
 21280       if (pt_row == NULL)
 21281         w->cursor.vpos = -1;
 21282       last_text_row = NULL;
 21283       while (it.current_y < it.last_visible_y && !f->fonts_changed)
 21284         if (display_line (&it, w->cursor.vpos))
 21285           last_text_row = it.glyph_row - 1;
 21286 
 21287       /* If point is in a reused row, adjust y and vpos of the cursor
 21288          position.  */
 21289       if (pt_row)
 21290         {
 21291           w->cursor.vpos -= nrows_scrolled;
 21292           w->cursor.y -= first_reusable_row->y - start_row->y;
 21293         }
 21294 
 21295       /* Give up if point isn't in a row displayed or reused.  (This
 21296          also handles the case where w->cursor.vpos < nrows_scrolled
 21297          after the calls to display_line, which can happen with scroll
 21298          margins.  See bug#1295.)  */
 21299       if (w->cursor.vpos < 0)
 21300         {
 21301           clear_glyph_matrix (w->desired_matrix);
 21302           return false;
 21303         }
 21304 
 21305       /* Scroll the display.  */
 21306       run.current_y = first_reusable_row->y;
 21307       run.desired_y = WINDOW_TAB_LINE_HEIGHT (w) + WINDOW_HEADER_LINE_HEIGHT (w);
 21308       run.height = it.last_visible_y - run.current_y;
 21309       dy = run.current_y - run.desired_y;
 21310 
 21311       if (run.height)
 21312         {
 21313 #ifdef HAVE_WINDOW_SYSTEM
 21314           update_begin (f);
 21315           gui_update_window_begin (w);
 21316           FRAME_RIF (f)->clear_window_mouse_face (w);
 21317           FRAME_RIF (f)->scroll_run_hook (w, &run);
 21318           gui_update_window_end (w, false, false);
 21319           update_end (f);
 21320 #endif
 21321         }
 21322 
 21323       /* Adjust Y positions of reused rows.  */
 21324       bottom_row = MATRIX_BOTTOM_TEXT_ROW (w->current_matrix, w);
 21325       min_y = WINDOW_TAB_LINE_HEIGHT (w) + WINDOW_HEADER_LINE_HEIGHT (w);
 21326       max_y = it.last_visible_y;
 21327       for (row = first_reusable_row; row < first_row_to_display; ++row)
 21328         {
 21329           row->y -= dy;
 21330           row->visible_height = row->height;
 21331           if (row->y < min_y)
 21332             row->visible_height -= min_y - row->y;
 21333           if (row->y + row->height > max_y)
 21334             row->visible_height -= row->y + row->height - max_y;
 21335           if (row->fringe_bitmap_periodic_p)
 21336             row->redraw_fringe_bitmaps_p = true;
 21337         }
 21338 
 21339       /* Scroll the current matrix.  */
 21340       eassert (nrows_scrolled > 0);
 21341       rotate_matrix (w->current_matrix,
 21342                      start_vpos,
 21343                      MATRIX_ROW_VPOS (bottom_row, w->current_matrix),
 21344                      -nrows_scrolled);
 21345 
 21346       /* Disable rows not reused.  */
 21347       for (row -= nrows_scrolled; row < bottom_row; ++row)
 21348         row->enabled_p = false;
 21349 
 21350       /* Point may have moved to a different line, so we cannot assume that
 21351          the previous cursor position is valid; locate the correct row.  */
 21352       if (pt_row)
 21353         {
 21354           for (row = MATRIX_ROW (w->current_matrix, w->cursor.vpos);
 21355                row < bottom_row
 21356                  && PT >= MATRIX_ROW_END_CHARPOS (row)
 21357                  && !row->ends_at_zv_p;
 21358                row++)
 21359             {
 21360               w->cursor.vpos++;
 21361               w->cursor.y = row->y;
 21362             }
 21363           if (row < bottom_row)
 21364             {
 21365               /* Can't simply scan the row for point with
 21366                  bidi-reordered glyph rows.  Let set_cursor_from_row
 21367                  figure out where to put the cursor, and if it fails,
 21368                  give up.  */
 21369               if (!NILP (BVAR (XBUFFER (w->contents), bidi_display_reordering)))
 21370                 {
 21371                   if (!set_cursor_from_row (w, row, w->current_matrix,
 21372                                             0, 0, 0, 0))
 21373                     {
 21374                       clear_glyph_matrix (w->desired_matrix);
 21375                       return false;
 21376                     }
 21377                 }
 21378               else
 21379                 {
 21380                   struct glyph *glyph = row->glyphs[TEXT_AREA] + w->cursor.hpos;
 21381                   struct glyph *end = row->glyphs[TEXT_AREA] + row->used[TEXT_AREA];
 21382 
 21383                   for (; glyph < end
 21384                          && (!BUFFERP (glyph->object)
 21385                              || glyph->charpos < PT);
 21386                        glyph++)
 21387                     {
 21388                       w->cursor.hpos++;
 21389                       w->cursor.x += glyph->pixel_width;
 21390                     }
 21391                 }
 21392             }
 21393         }
 21394 
 21395       /* Adjust window end.  A null value of last_text_row means that
 21396          the window end is in reused rows which in turn means that
 21397          only its vpos can have changed.  */
 21398       if (last_text_row)
 21399         adjust_window_ends (w, last_text_row, false);
 21400       else
 21401         w->window_end_vpos -= nrows_scrolled;
 21402 
 21403       w->window_end_valid = false;
 21404       w->desired_matrix->no_scrolling_p = true;
 21405 
 21406 #ifdef GLYPH_DEBUG
 21407       debug_method_add (w, "try_window_reusing_current_matrix 2");
 21408 #endif
 21409       return true;
 21410     }
 21411 
 21412   return false;
 21413 }
 21414 
 21415 
 21416 
 21417 /************************************************************************
 21418    Window redisplay reusing current matrix when buffer has changed
 21419  ************************************************************************/
 21420 
 21421 static struct glyph_row *find_last_unchanged_at_beg_row (struct window *);
 21422 static struct glyph_row *find_first_unchanged_at_end_row (struct window *,
 21423                                                           ptrdiff_t *, ptrdiff_t *);
 21424 static struct glyph_row *
 21425 find_last_row_displaying_text (struct glyph_matrix *, struct it *,
 21426                                struct glyph_row *);
 21427 
 21428 
 21429 /* Return the last row in MATRIX displaying text.  If row START is
 21430    non-null, start searching with that row.  IT gives the dimensions
 21431    of the display.  Value is null if matrix is empty; otherwise it is
 21432    a pointer to the row found.  */
 21433 
 21434 static struct glyph_row *
 21435 find_last_row_displaying_text (struct glyph_matrix *matrix, struct it *it,
 21436                                struct glyph_row *start)
 21437 {
 21438   struct glyph_row *row, *row_found;
 21439 
 21440   /* Set row_found to the last row in IT->w's current matrix
 21441      displaying text.  The loop looks funny but think of partially
 21442      visible lines.  */
 21443   row_found = NULL;
 21444   row = start ? start : MATRIX_FIRST_TEXT_ROW (matrix);
 21445   while (MATRIX_ROW_DISPLAYS_TEXT_P (row))
 21446     {
 21447       eassert (row->enabled_p);
 21448       row_found = row;
 21449       if (MATRIX_ROW_BOTTOM_Y (row) >= it->last_visible_y)
 21450         break;
 21451       ++row;
 21452     }
 21453 
 21454   return row_found;
 21455 }
 21456 
 21457 
 21458 /* Return the last row in the current matrix of W that is not affected
 21459    by changes at the start of current_buffer that occurred since W's
 21460    current matrix was built.  Value is null if no such row exists.
 21461 
 21462    BEG_UNCHANGED is the number of characters unchanged at the start of
 21463    current_buffer.  BEG + BEG_UNCHANGED is the buffer position of the
 21464    first changed character in current_buffer.  Characters at positions <
 21465    BEG + BEG_UNCHANGED are at the same buffer positions as they were
 21466    when the current matrix was built.  */
 21467 
 21468 static struct glyph_row *
 21469 find_last_unchanged_at_beg_row (struct window *w)
 21470 {
 21471   ptrdiff_t first_changed_pos = BEG + BEG_UNCHANGED;
 21472   struct glyph_row *row;
 21473   struct glyph_row *row_found = NULL;
 21474   int yb = window_text_bottom_y (w);
 21475 
 21476   /* Find the last row displaying unchanged text.  */
 21477   for (row = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
 21478        MATRIX_ROW_DISPLAYS_TEXT_P (row)
 21479          && MATRIX_ROW_START_CHARPOS (row) < first_changed_pos;
 21480        ++row)
 21481     {
 21482       if (/* If row ends before first_changed_pos, it is unchanged,
 21483              except in some case.  */
 21484           MATRIX_ROW_END_CHARPOS (row) <= first_changed_pos
 21485           /* When row ends in ZV and we write at ZV it is not
 21486              unchanged.  */
 21487           && !row->ends_at_zv_p
 21488           /* When first_changed_pos is the end of a continued line,
 21489              row is not unchanged because it may be no longer
 21490              continued.  */
 21491           && !(MATRIX_ROW_END_CHARPOS (row) == first_changed_pos
 21492                && (row->continued_p
 21493                    || row->exact_window_width_line_p))
 21494           /* If ROW->end is beyond ZV, then ROW->end is outdated and
 21495              needs to be recomputed, so don't consider this row as
 21496              unchanged.  This happens when the last line was
 21497              bidi-reordered and was killed immediately before this
 21498              redisplay cycle.  In that case, ROW->end stores the
 21499              buffer position of the first visual-order character of
 21500              the killed text, which is now beyond ZV.  */
 21501           && CHARPOS (row->end.pos) <= ZV)
 21502         row_found = row;
 21503 
 21504       /* Stop if last visible row.  */
 21505       if (MATRIX_ROW_BOTTOM_Y (row) >= yb)
 21506         break;
 21507     }
 21508 
 21509   return row_found;
 21510 }
 21511 
 21512 
 21513 /* Find the first glyph row in the current matrix of W that is not
 21514    affected by changes at the end of current_buffer since the
 21515    time W's current matrix was built.
 21516 
 21517    Return in *DELTA the number of chars by which buffer positions in
 21518    unchanged text at the end of current_buffer must be adjusted.
 21519 
 21520    Return in *DELTA_BYTES the corresponding number of bytes.
 21521 
 21522    Value is null if no such row exists, i.e. all rows are affected by
 21523    changes.  */
 21524 
 21525 static struct glyph_row *
 21526 find_first_unchanged_at_end_row (struct window *w,
 21527                                  ptrdiff_t *delta, ptrdiff_t *delta_bytes)
 21528 {
 21529   struct glyph_row *row;
 21530   struct glyph_row *row_found = NULL;
 21531 
 21532   *delta = *delta_bytes = 0;
 21533 
 21534   /* Display must not have been paused, otherwise the current matrix
 21535      is not up to date.  */
 21536   eassert (w->window_end_valid);
 21537 
 21538   /* A value of window_end_pos >= END_UNCHANGED means that the window
 21539      end is in the range of changed text.  If so, there is no
 21540      unchanged row at the end of W's current matrix.  */
 21541   if (w->window_end_pos >= END_UNCHANGED)
 21542     return NULL;
 21543 
 21544   /* Set row to the last row in W's current matrix displaying text.  */
 21545   row = MATRIX_ROW (w->current_matrix, w->window_end_vpos);
 21546 
 21547   /* If matrix is entirely empty, no unchanged row exists.  */
 21548   if (MATRIX_ROW_DISPLAYS_TEXT_P (row))
 21549     {
 21550       /* The value of row is the last glyph row in the matrix having a
 21551          meaningful buffer position in it.  The end position of row
 21552          corresponds to window_end_pos.  This allows us to translate
 21553          buffer positions in the current matrix to current buffer
 21554          positions for characters not in changed text.  */
 21555       ptrdiff_t Z_old =
 21556         MATRIX_ROW_END_CHARPOS (row) + w->window_end_pos;
 21557       ptrdiff_t Z_BYTE_old =
 21558         MATRIX_ROW_END_BYTEPOS (row) + w->window_end_bytepos;
 21559       ptrdiff_t last_unchanged_pos, last_unchanged_pos_old;
 21560       struct glyph_row *first_text_row
 21561         = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
 21562 
 21563       *delta = Z - Z_old;
 21564       *delta_bytes = Z_BYTE - Z_BYTE_old;
 21565 
 21566       /* Set last_unchanged_pos to the buffer position of the last
 21567          character in the buffer that has not been changed.  Z is the
 21568          index + 1 of the last character in current_buffer, i.e. by
 21569          subtracting END_UNCHANGED we get the index of the last
 21570          unchanged character, and we have to add BEG to get its buffer
 21571          position.  */
 21572       last_unchanged_pos = Z - END_UNCHANGED + BEG;
 21573       last_unchanged_pos_old = last_unchanged_pos - *delta;
 21574 
 21575       /* Search backward from ROW for a row displaying a line that
 21576          starts at a minimum position >= last_unchanged_pos_old.  */
 21577       for (; row > first_text_row; --row)
 21578         {
 21579           /* This used to abort, but it can happen.
 21580              It is ok to just stop the search instead here.  KFS.  */
 21581           if (!row->enabled_p || !MATRIX_ROW_DISPLAYS_TEXT_P (row))
 21582             break;
 21583 
 21584           if (MATRIX_ROW_START_CHARPOS (row) >= last_unchanged_pos_old)
 21585             row_found = row;
 21586         }
 21587     }
 21588 
 21589   eassert (!row_found || MATRIX_ROW_DISPLAYS_TEXT_P (row_found));
 21590 
 21591   return row_found;
 21592 }
 21593 
 21594 
 21595 /* Make sure that glyph rows in the current matrix of window W
 21596    reference the same glyph memory as corresponding rows in the
 21597    frame's frame matrix.  This function is called after scrolling W's
 21598    current matrix on a terminal frame in try_window_id and
 21599    try_window_reusing_current_matrix.  */
 21600 
 21601 static void
 21602 sync_frame_with_window_matrix_rows (struct window *w)
 21603 {
 21604   struct frame *f = XFRAME (w->frame);
 21605   struct glyph_row *window_row, *window_row_end, *frame_row;
 21606 
 21607   /* Preconditions: W must be a leaf window and full-width.  Its frame
 21608      must have a frame matrix.  */
 21609   eassert (BUFFERP (w->contents));
 21610   eassert (WINDOW_FULL_WIDTH_P (w));
 21611   eassert (!FRAME_WINDOW_P (f));
 21612 
 21613   /* If W is a full-width window, glyph pointers in W's current matrix
 21614      have, by definition, to be the same as glyph pointers in the
 21615      corresponding frame matrix.  Note that frame matrices have no
 21616      marginal areas (see build_frame_matrix).  */
 21617   window_row = w->current_matrix->rows;
 21618   window_row_end = window_row + w->current_matrix->nrows;
 21619   frame_row = f->current_matrix->rows + WINDOW_TOP_EDGE_LINE (w);
 21620   while (window_row < window_row_end)
 21621     {
 21622       struct glyph *start = window_row->glyphs[LEFT_MARGIN_AREA];
 21623       struct glyph *end = window_row->glyphs[LAST_AREA];
 21624 
 21625       frame_row->glyphs[LEFT_MARGIN_AREA] = start;
 21626       frame_row->glyphs[TEXT_AREA] = start;
 21627       frame_row->glyphs[RIGHT_MARGIN_AREA] = end;
 21628       frame_row->glyphs[LAST_AREA] = end;
 21629 
 21630       /* Disable frame rows whose corresponding window rows have
 21631          been disabled in try_window_id.  */
 21632       if (!window_row->enabled_p)
 21633         frame_row->enabled_p = false;
 21634 
 21635       ++window_row, ++frame_row;
 21636     }
 21637 }
 21638 
 21639 
 21640 /* Find the glyph row in window W containing CHARPOS.  Consider all
 21641    rows between START and END (not inclusive).  END null means search
 21642    all rows to the end of the display area of W.  Value is the row
 21643    containing CHARPOS or null.  */
 21644 
 21645 struct glyph_row *
 21646 row_containing_pos (struct window *w, ptrdiff_t charpos,
 21647                     struct glyph_row *start, struct glyph_row *end, int dy)
 21648 {
 21649   struct glyph_row *row = start;
 21650   struct glyph_row *best_row = NULL;
 21651   ptrdiff_t mindif = BUF_ZV (XBUFFER (w->contents)) + 1;
 21652   int last_y;
 21653 
 21654   /* If we happen to start on a header-line or a tab-line, skip that.  */
 21655   if (row->tab_line_p)
 21656     ++row;
 21657   if (row->mode_line_p)
 21658     ++row;
 21659 
 21660   if ((end && row >= end) || !row->enabled_p)
 21661     return NULL;
 21662 
 21663   last_y = window_text_bottom_y (w) - dy;
 21664 
 21665   while (true)
 21666     {
 21667       /* Give up if we have gone too far.  */
 21668       if ((end && row >= end) || !row->enabled_p)
 21669         return NULL;
 21670       /* This formerly returned if they were equal.
 21671          I think that both quantities are of a "last plus one" type;
 21672          if so, when they are equal, the row is within the screen. -- rms.  */
 21673       if (MATRIX_ROW_BOTTOM_Y (row) > last_y)
 21674         return NULL;
 21675 
 21676       /* If it is in this row, return this row.  */
 21677       if (! (MATRIX_ROW_END_CHARPOS (row) < charpos
 21678              || (MATRIX_ROW_END_CHARPOS (row) == charpos
 21679                  /* The end position of a row equals the start
 21680                     position of the next row.  If CHARPOS is there, we
 21681                     would rather consider it displayed in the next
 21682                     line, except when this line ends in ZV.  */
 21683                  && !row_for_charpos_p (row, charpos)))
 21684           && charpos >= MATRIX_ROW_START_CHARPOS (row))
 21685         {
 21686           struct glyph *g;
 21687 
 21688           if (NILP (BVAR (XBUFFER (w->contents), bidi_display_reordering))
 21689               || (!best_row && !row->continued_p))
 21690             return row;
 21691           /* In bidi-reordered rows, there could be several rows whose
 21692              edges surround CHARPOS, all of these rows belonging to
 21693              the same continued line.  We need to find the row which
 21694              fits CHARPOS the best.  */
 21695           for (g = row->glyphs[TEXT_AREA];
 21696                g < row->glyphs[TEXT_AREA] + row->used[TEXT_AREA];
 21697                g++)
 21698             {
 21699               if (!STRINGP (g->object))
 21700                 {
 21701                   if (g->charpos > 0 && eabs (g->charpos - charpos) < mindif)
 21702                     {
 21703                       mindif = eabs (g->charpos - charpos);
 21704                       best_row = row;
 21705                       /* Exact match always wins.  */
 21706                       if (mindif == 0)
 21707                         return best_row;
 21708                     }
 21709                 }
 21710             }
 21711         }
 21712       else if (best_row && !row->continued_p)
 21713         return best_row;
 21714       ++row;
 21715     }
 21716 }
 21717 
 21718 
 21719 /* Try to redisplay window W by reusing its existing display.  W's
 21720    current matrix must be up to date when this function is called,
 21721    i.e., window_end_valid must be true.
 21722 
 21723    Value is
 21724 
 21725    >= 1 if successful, i.e. display has been updated
 21726          specifically:
 21727          1 means the changes were in front of a newline that precedes
 21728            the window start, and the whole current matrix was reused
 21729          2 means the changes were after the last position displayed
 21730            in the window, and the whole current matrix was reused
 21731          3 means portions of the current matrix were reused, while
 21732            some of the screen lines were redrawn
 21733    -1   if redisplay with same window start is known not to succeed
 21734    0    if otherwise unsuccessful
 21735 
 21736    The following steps are performed:
 21737 
 21738    1. Find the last row in the current matrix of W that is not
 21739    affected by changes at the start of current_buffer.  If no such row
 21740    is found, give up.
 21741 
 21742    2. Find the first row in W's current matrix that is not affected by
 21743    changes at the end of current_buffer.  Maybe there is no such row.
 21744 
 21745    3. Display lines beginning with the row + 1 found in step 1 to the
 21746    row found in step 2 or, if step 2 didn't find a row, to the end of
 21747    the window.
 21748 
 21749    4. If cursor is not known to appear on the window, give up.
 21750 
 21751    5. If display stopped at the row found in step 2, scroll the
 21752    display and current matrix as needed.
 21753 
 21754    6. Maybe display some lines at the end of W, if we must.  This can
 21755    happen under various circumstances, like a partially visible line
 21756    becoming fully visible, or because newly displayed lines are displayed
 21757    in smaller font sizes.
 21758 
 21759    7. Update W's window end information.  */
 21760 
 21761 static int
 21762 try_window_id (struct window *w)
 21763 {
 21764   struct frame *f = XFRAME (w->frame);
 21765   struct glyph_matrix *current_matrix = w->current_matrix;
 21766   struct glyph_matrix *desired_matrix = w->desired_matrix;
 21767   struct glyph_row *last_unchanged_at_beg_row;
 21768   struct glyph_row *first_unchanged_at_end_row;
 21769   struct glyph_row *row;
 21770   struct glyph_row *bottom_row;
 21771   int bottom_vpos;
 21772   struct it it;
 21773   ptrdiff_t delta = 0, delta_bytes = 0, stop_pos;
 21774   int dvpos, dy;
 21775   struct text_pos start_pos;
 21776   struct run run;
 21777   int first_unchanged_at_end_vpos = 0;
 21778   struct glyph_row *last_text_row, *last_text_row_at_end;
 21779   struct text_pos start;
 21780   ptrdiff_t first_changed_charpos, last_changed_charpos;
 21781 
 21782 #ifdef GLYPH_DEBUG
 21783   if (inhibit_try_window_id)
 21784     return 0;
 21785 #endif
 21786 
 21787   /* This is handy for debugging.  */
 21788 #if false
 21789 #define GIVE_UP(X)                                              \
 21790   do {                                                          \
 21791     redisplay_trace ("try_window_id give up %d\n", X);          \
 21792     return 0;                                                   \
 21793   } while (false)
 21794 #else
 21795 #define GIVE_UP(X) return 0
 21796 #endif
 21797 
 21798   SET_TEXT_POS_FROM_MARKER (start, w->start);
 21799 
 21800   /* Don't use this for mini-windows because these can show
 21801      messages and mini-buffers, and we don't handle that here.  */
 21802   if (MINI_WINDOW_P (w))
 21803     GIVE_UP (1);
 21804 
 21805   /* This flag is used to prevent redisplay optimizations.  */
 21806   if (windows_or_buffers_changed || f->cursor_type_changed)
 21807     GIVE_UP (2);
 21808 
 21809   /* This function's optimizations cannot be used if overlays have
 21810      changed in the buffer displayed by the window, so give up if they
 21811      have.  */
 21812   if (w->last_overlay_modified != OVERLAY_MODIFF)
 21813     GIVE_UP (200);
 21814 
 21815   /* Verify that narrowing has not changed.
 21816      Also verify that we were not told to prevent redisplay optimizations.
 21817      It would be nice to further
 21818      reduce the number of cases where this prevents try_window_id.  */
 21819   if (current_buffer->clip_changed
 21820       || current_buffer->prevent_redisplay_optimizations_p)
 21821     GIVE_UP (3);
 21822 
 21823   /* Window must either use window-based redisplay or be full width.  */
 21824   if (!FRAME_WINDOW_P (f)
 21825       && (!FRAME_LINE_INS_DEL_OK (f)
 21826           || !WINDOW_FULL_WIDTH_P (w)))
 21827     GIVE_UP (4);
 21828 
 21829   /* Give up if point is known NOT to appear in W.  */
 21830   if (PT < CHARPOS (start))
 21831     GIVE_UP (5);
 21832 
 21833   /* Another way to prevent redisplay optimizations.  */
 21834   if (w->last_modified == 0)
 21835     GIVE_UP (6);
 21836 
 21837   /* Verify that window is not hscrolled.  */
 21838   if (w->hscroll != 0)
 21839     GIVE_UP (7);
 21840 
 21841   /* Verify that display wasn't paused.  */
 21842   if (!w->window_end_valid)
 21843     GIVE_UP (8);
 21844 
 21845   /* Likewise if highlighting trailing whitespace.  */
 21846   if (!NILP (Vshow_trailing_whitespace))
 21847     GIVE_UP (11);
 21848 
 21849   /* Can't use this if overlay arrow position and/or string have
 21850      changed.  */
 21851   if (overlay_arrows_changed_p (false))
 21852     GIVE_UP (12);
 21853 
 21854   /* When word-wrap is on, adding a space to the first word of a
 21855      wrapped line can change the wrap position, altering the line
 21856      above it.  It might be worthwhile to handle this more
 21857      intelligently, but for now just redisplay from scratch.  */
 21858   if (!NILP (BVAR (XBUFFER (w->contents), word_wrap)))
 21859     GIVE_UP (21);
 21860 
 21861   /* Under bidi reordering, adding or deleting a character in the
 21862      beginning of a paragraph, before the first strong directional
 21863      character, can change the base direction of the paragraph (unless
 21864      the buffer specifies a fixed paragraph direction), which will
 21865      require redisplaying the whole paragraph.  It might be worthwhile
 21866      to find the paragraph limits and widen the range of redisplayed
 21867      lines to that, but for now just give up this optimization and
 21868      redisplay from scratch.  */
 21869   if (!NILP (BVAR (XBUFFER (w->contents), bidi_display_reordering))
 21870       && NILP (BVAR (XBUFFER (w->contents), bidi_paragraph_direction)))
 21871     GIVE_UP (22);
 21872 
 21873   /* Give up if the buffer has line-spacing set, as Lisp-level changes
 21874      to that variable require thorough redisplay.  */
 21875   if (!NILP (BVAR (XBUFFER (w->contents), extra_line_spacing)))
 21876     GIVE_UP (23);
 21877 
 21878   /* Give up if display-line-numbers is in relative mode, or when the
 21879      current line's number needs to be displayed in a distinct face.  */
 21880   if (EQ (Vdisplay_line_numbers, Qrelative)
 21881       || EQ (Vdisplay_line_numbers, Qvisual)
 21882       || (!NILP (Vdisplay_line_numbers)
 21883           && NILP (Finternal_lisp_face_equal_p (Qline_number,
 21884                                                 Qline_number_current_line,
 21885                                                 w->frame))))
 21886     GIVE_UP (24);
 21887 
 21888   /* composition-break-at-point is incompatible with the optimizations
 21889      in this function, because we need to recompose characters when
 21890      point moves off their positions.  */
 21891   if (composition_break_at_point)
 21892     GIVE_UP (27);
 21893 
 21894   /* Make sure beg_unchanged and end_unchanged are up to date.  Do it
 21895      only if buffer has really changed.  The reason is that the gap is
 21896      initially at Z for freshly visited files.  The code below would
 21897      set end_unchanged to 0 in that case.  */
 21898   if (MODIFF > SAVE_MODIFF
 21899       /* This seems to happen sometimes after saving a buffer.  */
 21900       || BEG_UNCHANGED + END_UNCHANGED > Z_BYTE)
 21901     {
 21902       if (GPT - BEG < BEG_UNCHANGED)
 21903         BEG_UNCHANGED = GPT - BEG;
 21904       if (Z - GPT < END_UNCHANGED)
 21905         END_UNCHANGED = Z - GPT;
 21906     }
 21907 
 21908   /* The position of the first and last character that has been changed.  */
 21909   first_changed_charpos = BEG + BEG_UNCHANGED;
 21910   last_changed_charpos  = Z - END_UNCHANGED;
 21911 
 21912   /* If window starts after a line end, and the last change is in
 21913      front of that newline, then changes don't affect the display.
 21914      This case happens with stealth-fontification.  Note that although
 21915      the display is unchanged, glyph positions in the matrix have to
 21916      be adjusted, of course.  */
 21917   row = MATRIX_ROW (w->current_matrix, w->window_end_vpos);
 21918   if (MATRIX_ROW_DISPLAYS_TEXT_P (row)
 21919       && ((last_changed_charpos < CHARPOS (start)
 21920            && CHARPOS (start) == BEGV)
 21921           || (last_changed_charpos < CHARPOS (start) - 1
 21922               && FETCH_BYTE (BYTEPOS (start) - 1) == '\n')))
 21923     {
 21924       ptrdiff_t Z_old, Z_delta, Z_BYTE_old, Z_delta_bytes;
 21925       struct glyph_row *r0;
 21926 
 21927       /* Compute how many chars/bytes have been added to or removed
 21928          from the buffer.  */
 21929       Z_old = MATRIX_ROW_END_CHARPOS (row) + w->window_end_pos;
 21930       Z_BYTE_old = MATRIX_ROW_END_BYTEPOS (row) + w->window_end_bytepos;
 21931       Z_delta = Z - Z_old;
 21932       Z_delta_bytes = Z_BYTE - Z_BYTE_old;
 21933 
 21934       /* Give up if PT is not in the window.  Note that it already has
 21935          been checked at the start of try_window_id that PT is not in
 21936          front of the window start.  */
 21937       if (PT >= MATRIX_ROW_END_CHARPOS (row) + Z_delta)
 21938         GIVE_UP (13);
 21939 
 21940       /* If window start is unchanged, we can reuse the whole matrix
 21941          as is, after adjusting glyph positions.  No need to compute
 21942          the window end again, since its offset from Z hasn't changed.  */
 21943       r0 = MATRIX_FIRST_TEXT_ROW (current_matrix);
 21944       if (CHARPOS (start) == MATRIX_ROW_START_CHARPOS (r0) + Z_delta
 21945           && BYTEPOS (start) == MATRIX_ROW_START_BYTEPOS (r0) + Z_delta_bytes
 21946           /* PT must not be in a partially visible line.  */
 21947           && !(PT >= MATRIX_ROW_START_CHARPOS (row) + Z_delta
 21948                && MATRIX_ROW_BOTTOM_Y (row) > window_text_bottom_y (w)))
 21949         {
 21950           /* Adjust positions in the glyph matrix.  */
 21951           if (Z_delta || Z_delta_bytes)
 21952             {
 21953               struct glyph_row *r1
 21954                 = MATRIX_BOTTOM_TEXT_ROW (current_matrix, w);
 21955               increment_matrix_positions (w->current_matrix,
 21956                                           MATRIX_ROW_VPOS (r0, current_matrix),
 21957                                           MATRIX_ROW_VPOS (r1, current_matrix),
 21958                                           Z_delta, Z_delta_bytes);
 21959             }
 21960 
 21961           /* Set the cursor.  */
 21962           row = row_containing_pos (w, PT, r0, NULL, 0);
 21963           if (row)
 21964             set_cursor_from_row (w, row, current_matrix, 0, 0, 0, 0);
 21965           return 1;
 21966         }
 21967     }
 21968 
 21969   /* Handle the case that changes are all below what is displayed in
 21970      the window, and that PT is in the window.  This shortcut cannot
 21971      be taken if ZV is visible in the window, and text has been added
 21972      there that is visible in the window.  */
 21973   if (first_changed_charpos >= MATRIX_ROW_END_CHARPOS (row)
 21974       /* ZV is not visible in the window, or there are no
 21975          changes at ZV, actually.  */
 21976       && (current_matrix->zv > MATRIX_ROW_END_CHARPOS (row)
 21977           || first_changed_charpos == last_changed_charpos))
 21978     {
 21979       struct glyph_row *r0;
 21980 
 21981       /* Give up if PT is not in the window.  Note that it already has
 21982          been checked at the start of try_window_id that PT is not in
 21983          front of the window start.  */
 21984       if (PT >= MATRIX_ROW_END_CHARPOS (row))
 21985         GIVE_UP (14);
 21986 
 21987       /* If window start is unchanged, we can reuse the whole matrix
 21988          as is, without changing glyph positions since no text has
 21989          been added/removed in front of the window end.  */
 21990       r0 = MATRIX_FIRST_TEXT_ROW (current_matrix);
 21991       if (TEXT_POS_EQUAL_P (start, r0->minpos)
 21992           /* PT must not be in a partially visible line.  */
 21993           && !(PT >= MATRIX_ROW_START_CHARPOS (row)
 21994                && MATRIX_ROW_BOTTOM_Y (row) > window_text_bottom_y (w)))
 21995         {
 21996           /* We have to compute the window end anew since text
 21997              could have been added/removed after it.  */
 21998           w->window_end_pos = Z - MATRIX_ROW_END_CHARPOS (row);
 21999           w->window_end_bytepos = Z_BYTE - MATRIX_ROW_END_BYTEPOS (row);
 22000 
 22001           /* Set the cursor.  */
 22002           row = row_containing_pos (w, PT, r0, NULL, 0);
 22003           if (row)
 22004             set_cursor_from_row (w, row, current_matrix, 0, 0, 0, 0);
 22005           return 2;
 22006         }
 22007     }
 22008 
 22009   /* Give up if window start is in the changed area.
 22010 
 22011      The condition used to read
 22012 
 22013      (BEG_UNCHANGED + END_UNCHANGED != Z - BEG && ...)
 22014 
 22015      but why that was tested escapes me at the moment.  */
 22016   if (CHARPOS (start) >= first_changed_charpos
 22017       && CHARPOS (start) <= last_changed_charpos)
 22018     GIVE_UP (15);
 22019 
 22020   /* Check that window start agrees with the start of the first glyph
 22021      row in its current matrix.  Check this after we know the window
 22022      start is not in changed text, otherwise positions would not be
 22023      comparable.  */
 22024   row = MATRIX_FIRST_TEXT_ROW (current_matrix);
 22025   if (!TEXT_POS_EQUAL_P (start, row->minpos))
 22026     GIVE_UP (16);
 22027 
 22028   /* Give up if the window ends in strings.  Overlay strings
 22029      at the end are difficult to handle, so don't try.  */
 22030   row = MATRIX_ROW (current_matrix, w->window_end_vpos);
 22031   if (MATRIX_ROW_START_CHARPOS (row) == MATRIX_ROW_END_CHARPOS (row))
 22032     GIVE_UP (20);
 22033 
 22034   /* Can't let scroll_run_hook below run on w32 GUI frames when
 22035      position of point is indicated by the system caret, because
 22036      scrolling the display will then "copy" the pixels used by the
 22037      caret.  */
 22038 #ifdef HAVE_NTGUI
 22039   if (FRAME_W32_P (f) && w32_use_visible_system_caret)
 22040     GIVE_UP (25);
 22041 #endif
 22042 
 22043   /* Compute the position at which we have to start displaying new
 22044      lines.  Some of the lines at the top of the window might be
 22045      reusable because they are not displaying changed text.  Find the
 22046      last row in W's current matrix not affected by changes at the
 22047      start of current_buffer.  Value is null if changes start in the
 22048      first line of window.  */
 22049   last_unchanged_at_beg_row = find_last_unchanged_at_beg_row (w);
 22050   if (last_unchanged_at_beg_row)
 22051     {
 22052       /* Avoid starting to display in the middle of a character, a TAB
 22053          for instance.  This is easier than to set up the iterator
 22054          exactly, and it's not a frequent case, so the additional
 22055          effort wouldn't really pay off.  */
 22056       while ((MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (last_unchanged_at_beg_row)
 22057               || last_unchanged_at_beg_row->ends_in_newline_from_string_p)
 22058              && last_unchanged_at_beg_row > w->current_matrix->rows)
 22059         --last_unchanged_at_beg_row;
 22060 
 22061       if (MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (last_unchanged_at_beg_row))
 22062         GIVE_UP (17);
 22063 
 22064       if (! init_to_row_end (&it, w, last_unchanged_at_beg_row))
 22065         GIVE_UP (18);
 22066       /* Give up if the row starts with a display property that draws
 22067          on the fringes, since that could prevent correct display of
 22068          line-prefix and wrap-prefix.  */
 22069       if (it.sp > 1
 22070           && it.method == GET_FROM_IMAGE && it.image_id == -1)
 22071         GIVE_UP (26);
 22072       start_pos = it.current.pos;
 22073 
 22074       /* Start displaying new lines in the desired matrix at the same
 22075          vpos we would use in the current matrix, i.e. below
 22076          last_unchanged_at_beg_row.  */
 22077       it.vpos = 1 + MATRIX_ROW_VPOS (last_unchanged_at_beg_row,
 22078                                      current_matrix);
 22079       it.glyph_row = MATRIX_ROW (desired_matrix, it.vpos);
 22080       it.current_y = MATRIX_ROW_BOTTOM_Y (last_unchanged_at_beg_row);
 22081 
 22082       eassert (it.hpos == 0 && it.current_x == 0);
 22083     }
 22084   else
 22085     {
 22086       /* There are no reusable lines at the start of the window.
 22087          Start displaying in the first text line.  */
 22088       start_display (&it, w, start);
 22089       it.vpos = it.first_vpos;
 22090       start_pos = it.current.pos;
 22091     }
 22092 
 22093   /* Find the first row that is not affected by changes at the end of
 22094      the buffer.  Value will be null if there is no unchanged row, in
 22095      which case we must redisplay to the end of the window.  delta
 22096      will be set to the value by which buffer positions beginning with
 22097      first_unchanged_at_end_row have to be adjusted due to text
 22098      changes.  */
 22099   first_unchanged_at_end_row
 22100     = find_first_unchanged_at_end_row (w, &delta, &delta_bytes);
 22101   IF_DEBUG (debug_delta = delta);
 22102   IF_DEBUG (debug_delta_bytes = delta_bytes);
 22103 
 22104   /* Set stop_pos to the buffer position up to which we will have to
 22105      display new lines.  If first_unchanged_at_end_row != NULL, this
 22106      is the buffer position of the start of the line displayed in that
 22107      row.  For first_unchanged_at_end_row == NULL, use 0 to indicate
 22108      that we don't stop at a buffer position.  */
 22109   stop_pos = 0;
 22110   if (first_unchanged_at_end_row)
 22111     {
 22112       eassert (last_unchanged_at_beg_row == NULL
 22113                || first_unchanged_at_end_row >= last_unchanged_at_beg_row);
 22114 
 22115       /* If this is a continuation line, move forward to the next one
 22116          that isn't.  Changes in lines above affect this line.
 22117          Caution: this may move first_unchanged_at_end_row to a row
 22118          not displaying text.  */
 22119       while (MATRIX_ROW_CONTINUATION_LINE_P (first_unchanged_at_end_row)
 22120              && MATRIX_ROW_DISPLAYS_TEXT_P (first_unchanged_at_end_row)
 22121              && (MATRIX_ROW_BOTTOM_Y (first_unchanged_at_end_row)
 22122                  < it.last_visible_y))
 22123         ++first_unchanged_at_end_row;
 22124 
 22125       if (!MATRIX_ROW_DISPLAYS_TEXT_P (first_unchanged_at_end_row)
 22126           || (MATRIX_ROW_BOTTOM_Y (first_unchanged_at_end_row)
 22127               >= it.last_visible_y))
 22128         first_unchanged_at_end_row = NULL;
 22129       else
 22130         {
 22131           stop_pos = (MATRIX_ROW_START_CHARPOS (first_unchanged_at_end_row)
 22132                       + delta);
 22133           first_unchanged_at_end_vpos
 22134             = MATRIX_ROW_VPOS (first_unchanged_at_end_row, current_matrix);
 22135           eassert (stop_pos >= Z - END_UNCHANGED);
 22136         }
 22137     }
 22138   else if (last_unchanged_at_beg_row == NULL)
 22139     GIVE_UP (19);
 22140 
 22141 
 22142 #ifdef GLYPH_DEBUG
 22143 
 22144   /* Either there is no unchanged row at the end, or the one we have
 22145      now displays text.  This is a necessary condition for the window
 22146      end pos calculation at the end of this function.  */
 22147   eassert (first_unchanged_at_end_row == NULL
 22148            || MATRIX_ROW_DISPLAYS_TEXT_P (first_unchanged_at_end_row));
 22149 
 22150   debug_last_unchanged_at_beg_vpos
 22151     = (last_unchanged_at_beg_row
 22152        ? MATRIX_ROW_VPOS (last_unchanged_at_beg_row, current_matrix)
 22153        : -1);
 22154   debug_first_unchanged_at_end_vpos = first_unchanged_at_end_vpos;
 22155 
 22156 #endif /* GLYPH_DEBUG */
 22157 
 22158 
 22159   /* Display new lines.  Set last_text_row to the last new line
 22160      displayed which has text on it, i.e. might end up as being the
 22161      line where the window_end_vpos is.  */
 22162   w->cursor.vpos = -1;
 22163   last_text_row = NULL;
 22164   overlay_arrow_seen = false;
 22165   if (it.current_y < it.last_visible_y
 22166       && !f->fonts_changed
 22167       && (first_unchanged_at_end_row == NULL
 22168           || IT_CHARPOS (it) < stop_pos))
 22169     it.glyph_row->reversed_p = false;
 22170   while (it.current_y < it.last_visible_y
 22171          && !f->fonts_changed
 22172          && (first_unchanged_at_end_row == NULL
 22173              || IT_CHARPOS (it) < stop_pos))
 22174     {
 22175       if (display_line (&it, -1))
 22176         last_text_row = it.glyph_row - 1;
 22177     }
 22178 
 22179   if (f->fonts_changed)
 22180     return -1;
 22181 
 22182   /* The redisplay iterations in display_line above could have
 22183      triggered font-lock, which could have done something that
 22184      invalidates IT->w window's end-point information, on which we
 22185      rely below.  E.g., one package, which will remain unnamed, used
 22186      to install a font-lock-fontify-region-function that called
 22187      bury-buffer, whose side effect is to switch the buffer displayed
 22188      by IT->w, and that predictably resets IT->w's window_end_valid
 22189      flag, which we already tested at the entry to this function.
 22190      Amply punish such packages/modes by giving up on this
 22191      optimization in those cases.  */
 22192   if (!w->window_end_valid)
 22193     {
 22194       clear_glyph_matrix (w->desired_matrix);
 22195       return -1;
 22196     }
 22197 
 22198   /* Compute differences in buffer positions, y-positions etc.  for
 22199      lines reused at the bottom of the window.  Compute what we can
 22200      scroll.  */
 22201   if (first_unchanged_at_end_row
 22202       /* No lines reused because we displayed everything up to the
 22203          bottom of the window.  */
 22204       && it.current_y < it.last_visible_y)
 22205     {
 22206       dvpos = (it.vpos
 22207                - MATRIX_ROW_VPOS (first_unchanged_at_end_row,
 22208                                   current_matrix));
 22209       dy = it.current_y - first_unchanged_at_end_row->y;
 22210       run.current_y = first_unchanged_at_end_row->y;
 22211       run.desired_y = run.current_y + dy;
 22212       run.height = it.last_visible_y - max (run.current_y, run.desired_y);
 22213     }
 22214   else
 22215     {
 22216       delta = delta_bytes = dvpos = dy
 22217         = run.current_y = run.desired_y = run.height = 0;
 22218       first_unchanged_at_end_row = NULL;
 22219     }
 22220   IF_DEBUG ((debug_dvpos = dvpos, debug_dy = dy));
 22221 
 22222 
 22223   /* Find the cursor if not already found.  We have to decide whether
 22224      PT will appear on this window (it sometimes doesn't, but this is
 22225      not a very frequent case.)  This decision has to be made before
 22226      the current matrix is altered.  A value of cursor.vpos < 0 means
 22227      that PT is either in one of the lines beginning at
 22228      first_unchanged_at_end_row or below the window.  Don't care for
 22229      lines that might be displayed later at the window end; as
 22230      mentioned, this is not a frequent case.  */
 22231   if (w->cursor.vpos < 0)
 22232     {
 22233       /* Cursor in unchanged rows at the top?  */
 22234       if (PT < CHARPOS (start_pos)
 22235           && last_unchanged_at_beg_row)
 22236         {
 22237           row = row_containing_pos (w, PT,
 22238                                     MATRIX_FIRST_TEXT_ROW (w->current_matrix),
 22239                                     last_unchanged_at_beg_row + 1, 0);
 22240           if (row)
 22241             set_cursor_from_row (w, row, w->current_matrix, 0, 0, 0, 0);
 22242         }
 22243 
 22244       /* Start from first_unchanged_at_end_row looking for PT.  */
 22245       else if (first_unchanged_at_end_row)
 22246         {
 22247           row = row_containing_pos (w, PT - delta,
 22248                                     first_unchanged_at_end_row, NULL, 0);
 22249           if (row)
 22250             set_cursor_from_row (w, row, w->current_matrix, delta,
 22251                                  delta_bytes, dy, dvpos);
 22252         }
 22253 
 22254       /* Give up if cursor was not found.  */
 22255       if (w->cursor.vpos < 0)
 22256         {
 22257           clear_glyph_matrix (w->desired_matrix);
 22258           return -1;
 22259         }
 22260     }
 22261 
 22262   /* Don't let the cursor end in the scroll margins.  */
 22263   {
 22264     int top_scroll_margin = window_scroll_margin (w, MARGIN_IN_PIXELS);
 22265     int bot_scroll_margin = top_scroll_margin;
 22266     int cursor_height = MATRIX_ROW (w->desired_matrix, w->cursor.vpos)->height;
 22267 
 22268     if (window_wants_header_line (w))
 22269       top_scroll_margin += CURRENT_HEADER_LINE_HEIGHT (w);
 22270     if (window_wants_tab_line (w))
 22271       top_scroll_margin += CURRENT_TAB_LINE_HEIGHT (w);
 22272 
 22273     if ((w->cursor.y < top_scroll_margin
 22274          && CHARPOS (start) > BEGV)
 22275         /* Old redisplay didn't take scroll margin into account at the bottom,
 22276            but then global-hl-line-mode doesn't scroll.  KFS 2004-06-14 */
 22277         || (w->cursor.y
 22278             + (cursor_row_fully_visible_p (w, false, true, true)
 22279                ? 1
 22280                : cursor_height + bot_scroll_margin)) > it.last_visible_y)
 22281       {
 22282         w->cursor.vpos = -1;
 22283         clear_glyph_matrix (w->desired_matrix);
 22284         return -1;
 22285       }
 22286   }
 22287 
 22288   /* Scroll the display.  Do it before changing the current matrix so
 22289      that xterm.c doesn't get confused about where the cursor glyph is
 22290      found.  */
 22291   if (dy && run.height)
 22292     {
 22293       update_begin (f);
 22294 
 22295       if (FRAME_WINDOW_P (f))
 22296         {
 22297 #ifdef HAVE_WINDOW_SYSTEM
 22298           gui_update_window_begin (w);
 22299           FRAME_RIF (f)->clear_window_mouse_face (w);
 22300           FRAME_RIF (f)->scroll_run_hook (w, &run);
 22301           gui_update_window_end (w, false, false);
 22302 #endif
 22303         }
 22304       else
 22305         {
 22306           /* Terminal frame.  In this case, dvpos gives the number of
 22307              lines to scroll by; dvpos < 0 means scroll up.  */
 22308           int from_vpos
 22309             = MATRIX_ROW_VPOS (first_unchanged_at_end_row, w->current_matrix);
 22310           int from = WINDOW_TOP_EDGE_LINE (w) + from_vpos;
 22311           int end = (WINDOW_TOP_EDGE_LINE (w)
 22312                      + window_wants_tab_line (w)
 22313                      + window_wants_header_line (w)
 22314                      + window_internal_height (w));
 22315 
 22316           gui_clear_window_mouse_face (w);
 22317 
 22318           /* Perform the operation on the screen.  */
 22319           if (dvpos > 0)
 22320             {
 22321               /* Scroll last_unchanged_at_beg_row to the end of the
 22322                  window down dvpos lines.  */
 22323               set_terminal_window (f, end);
 22324 
 22325               /* On dumb terminals delete dvpos lines at the end
 22326                  before inserting dvpos empty lines.  */
 22327               if (!FRAME_SCROLL_REGION_OK (f))
 22328                 ins_del_lines (f, end - dvpos, -dvpos);
 22329 
 22330               /* Insert dvpos empty lines in front of
 22331                  last_unchanged_at_beg_row.  */
 22332               ins_del_lines (f, from, dvpos);
 22333             }
 22334           else if (dvpos < 0)
 22335             {
 22336               /* Scroll up last_unchanged_at_beg_vpos to the end of
 22337                  the window to last_unchanged_at_beg_vpos - |dvpos|.  */
 22338               set_terminal_window (f, end);
 22339 
 22340               /* Delete dvpos lines in front of
 22341                  last_unchanged_at_beg_vpos.  ins_del_lines will set
 22342                  the cursor to the given vpos and emit |dvpos| delete
 22343                  line sequences.  */
 22344               ins_del_lines (f, from + dvpos, dvpos);
 22345 
 22346               /* On a dumb terminal insert dvpos empty lines at the
 22347                  end.  */
 22348               if (!FRAME_SCROLL_REGION_OK (f))
 22349                 ins_del_lines (f, end + dvpos, -dvpos);
 22350             }
 22351 
 22352           set_terminal_window (f, 0);
 22353         }
 22354 
 22355       update_end (f);
 22356     }
 22357 
 22358   /* Shift reused rows of the current matrix to the right position.
 22359      BOTTOM_ROW is the last + 1 row in the current matrix reserved for
 22360      text.  */
 22361   bottom_row = MATRIX_BOTTOM_TEXT_ROW (current_matrix, w);
 22362   bottom_vpos = MATRIX_ROW_VPOS (bottom_row, current_matrix);
 22363   if (dvpos < 0)
 22364     {
 22365       rotate_matrix (current_matrix, first_unchanged_at_end_vpos + dvpos,
 22366                      bottom_vpos, dvpos);
 22367       clear_glyph_matrix_rows (current_matrix, bottom_vpos + dvpos,
 22368                                bottom_vpos);
 22369     }
 22370   else if (dvpos > 0)
 22371     {
 22372       rotate_matrix (current_matrix, first_unchanged_at_end_vpos,
 22373                      bottom_vpos, dvpos);
 22374       clear_glyph_matrix_rows (current_matrix, first_unchanged_at_end_vpos,
 22375                                first_unchanged_at_end_vpos + dvpos);
 22376     }
 22377 
 22378   /* For frame-based redisplay, make sure that current frame and window
 22379      matrix are in sync with respect to glyph memory.  */
 22380   if (!FRAME_WINDOW_P (f))
 22381     sync_frame_with_window_matrix_rows (w);
 22382 
 22383   /* Adjust buffer positions in reused rows.  */
 22384   if (delta || delta_bytes)
 22385     increment_matrix_positions (current_matrix,
 22386                                 first_unchanged_at_end_vpos + dvpos,
 22387                                 bottom_vpos, delta, delta_bytes);
 22388 
 22389   /* Adjust Y positions.  */
 22390   if (dy)
 22391     shift_glyph_matrix (w, current_matrix,
 22392                         first_unchanged_at_end_vpos + dvpos,
 22393                         bottom_vpos, dy);
 22394 
 22395   if (first_unchanged_at_end_row)
 22396     {
 22397       first_unchanged_at_end_row += dvpos;
 22398       if (first_unchanged_at_end_row->y >= it.last_visible_y
 22399           || !MATRIX_ROW_DISPLAYS_TEXT_P (first_unchanged_at_end_row))
 22400         first_unchanged_at_end_row = NULL;
 22401     }
 22402 
 22403   /* If scrolling up, there may be some lines to display at the end of
 22404      the window.  */
 22405   last_text_row_at_end = NULL;
 22406   if (dy < 0)
 22407     {
 22408       /* Scrolling up can leave for example a partially visible line
 22409          at the end of the window to be redisplayed.  */
 22410       /* Set last_row to the glyph row in the current matrix where the
 22411          window end line is found.  It has been moved up or down in
 22412          the matrix by dvpos.  */
 22413       int last_vpos = w->window_end_vpos + dvpos;
 22414       struct glyph_row *last_row = MATRIX_ROW (current_matrix, last_vpos);
 22415 
 22416       /* If last_row is the window end line, it should display text.  */
 22417       eassert (MATRIX_ROW_DISPLAYS_TEXT_P (last_row));
 22418 
 22419       /* If window end line was partially visible before, begin
 22420          displaying at that line.  Otherwise begin displaying with the
 22421          line following it.  */
 22422       if (MATRIX_ROW_BOTTOM_Y (last_row) - dy >= it.last_visible_y)
 22423         {
 22424           init_to_row_start (&it, w, last_row);
 22425           it.vpos = last_vpos;
 22426           it.current_y = last_row->y;
 22427         }
 22428       else
 22429         {
 22430           init_to_row_end (&it, w, last_row);
 22431           it.vpos = 1 + last_vpos;
 22432           it.current_y = MATRIX_ROW_BOTTOM_Y (last_row);
 22433           ++last_row;
 22434         }
 22435 
 22436       /* We may start in a continuation line.  If so, we have to
 22437          get the right continuation_lines_width and current_x.  */
 22438       it.continuation_lines_width = last_row->continuation_lines_width;
 22439       it.hpos = it.current_x = 0;
 22440 
 22441       /* Display the rest of the lines at the window end.  */
 22442       it.glyph_row = MATRIX_ROW (desired_matrix, it.vpos);
 22443       while (it.current_y < it.last_visible_y && !f->fonts_changed)
 22444         {
 22445           /* Is it always sure that the display agrees with lines in
 22446              the current matrix?  I don't think so, so we mark rows
 22447              displayed invalid in the current matrix by setting their
 22448              enabled_p flag to false.  */
 22449           SET_MATRIX_ROW_ENABLED_P (w->current_matrix, it.vpos, false);
 22450           if (display_line (&it, w->cursor.vpos))
 22451             last_text_row_at_end = it.glyph_row - 1;
 22452         }
 22453     }
 22454 
 22455   /* Update window_end_pos and window_end_vpos.  */
 22456   if (first_unchanged_at_end_row && !last_text_row_at_end)
 22457     {
 22458       /* Window end line if one of the preserved rows from the current
 22459          matrix.  Set row to the last row displaying text in current
 22460          matrix starting at first_unchanged_at_end_row, after
 22461          scrolling.  */
 22462       eassert (MATRIX_ROW_DISPLAYS_TEXT_P (first_unchanged_at_end_row));
 22463       row = find_last_row_displaying_text (w->current_matrix, &it,
 22464                                            first_unchanged_at_end_row);
 22465       eassume (row && MATRIX_ROW_DISPLAYS_TEXT_P (row));
 22466       adjust_window_ends (w, row, true);
 22467       eassert (w->window_end_bytepos >= 0);
 22468       IF_DEBUG (debug_method_add (w, "A"));
 22469     }
 22470   else if (last_text_row_at_end)
 22471     {
 22472       adjust_window_ends (w, last_text_row_at_end, false);
 22473       eassert (w->window_end_bytepos >= 0);
 22474       IF_DEBUG (debug_method_add (w, "B"));
 22475     }
 22476   else if (last_text_row)
 22477     {
 22478       /* We have displayed either to the end of the window or at the
 22479          end of the window, i.e. the last row with text is to be found
 22480          in the desired matrix.  */
 22481       adjust_window_ends (w, last_text_row, false);
 22482       eassert (w->window_end_bytepos >= 0);
 22483     }
 22484   else if (first_unchanged_at_end_row == NULL
 22485            && last_text_row == NULL
 22486            && last_text_row_at_end == NULL)
 22487     {
 22488       /* Displayed to end of window, but no line containing text was
 22489          displayed.  Lines were deleted at the end of the window.  */
 22490       int first_vpos = window_wants_tab_line (w) + window_wants_header_line (w);
 22491       int vpos = w->window_end_vpos;
 22492       struct glyph_row *current_row = current_matrix->rows + vpos;
 22493       struct glyph_row *desired_row = desired_matrix->rows + vpos;
 22494 
 22495       for (row = NULL; !row; --vpos, --current_row, --desired_row)
 22496         {
 22497           eassert (first_vpos <= vpos);
 22498           if (desired_row->enabled_p)
 22499             {
 22500               if (MATRIX_ROW_DISPLAYS_TEXT_P (desired_row))
 22501                 row = desired_row;
 22502             }
 22503           else if (MATRIX_ROW_DISPLAYS_TEXT_P (current_row))
 22504             row  = current_row;
 22505         }
 22506 
 22507       w->window_end_vpos = vpos + 1;
 22508       w->window_end_pos = Z - MATRIX_ROW_END_CHARPOS (row);
 22509       w->window_end_bytepos = Z_BYTE - MATRIX_ROW_END_BYTEPOS (row);
 22510       eassert (w->window_end_bytepos >= 0);
 22511       IF_DEBUG (debug_method_add (w, "C"));
 22512     }
 22513   else
 22514     emacs_abort ();
 22515 
 22516   IF_DEBUG ((debug_end_pos = w->window_end_pos,
 22517              debug_end_vpos = w->window_end_vpos));
 22518 
 22519   /* Record that display has not been completed.  */
 22520   w->window_end_valid = false;
 22521   w->desired_matrix->no_scrolling_p = true;
 22522   return 3;
 22523 
 22524 #undef GIVE_UP
 22525 }
 22526 
 22527 
 22528 
 22529 /***********************************************************************
 22530                         More debugging support
 22531  ***********************************************************************/
 22532 
 22533 #ifdef GLYPH_DEBUG
 22534 
 22535 void dump_glyph_row (struct glyph_row *, int, int) EXTERNALLY_VISIBLE;
 22536 void dump_glyph_matrix (struct glyph_matrix *, int) EXTERNALLY_VISIBLE;
 22537 void dump_glyph (struct glyph_row *, struct glyph *, int) EXTERNALLY_VISIBLE;
 22538 
 22539 
 22540 /* Dump the contents of glyph matrix MATRIX on stderr.
 22541 
 22542    GLYPHS 0 means don't show glyph contents.
 22543    GLYPHS 1 means show glyphs in short form
 22544    GLYPHS > 1 means show glyphs in long form.  */
 22545 
 22546 void
 22547 dump_glyph_matrix (struct glyph_matrix *matrix, int glyphs)
 22548 {
 22549   int i;
 22550   for (i = 0; i < matrix->nrows; ++i)
 22551     dump_glyph_row (MATRIX_ROW (matrix, i), i, glyphs);
 22552 }
 22553 
 22554 
 22555 /* Dump contents of glyph GLYPH to stderr.  ROW and AREA are
 22556    the glyph row and area where the glyph comes from.  */
 22557 
 22558 void
 22559 dump_glyph (struct glyph_row *row, struct glyph *glyph, int area)
 22560 {
 22561   if (glyph->type == CHAR_GLYPH
 22562       || glyph->type == GLYPHLESS_GLYPH)
 22563     {
 22564       fprintf (stderr,
 22565                "  %5"pD"d     %c %9"pD"d   %c %3d 0x%06x      %c %4d %1.1d%1.1d\n",
 22566                glyph - row->glyphs[TEXT_AREA],
 22567                (glyph->type == CHAR_GLYPH
 22568                 ? 'C'
 22569                 : 'G'),
 22570                glyph->charpos,
 22571                (BUFFERP (glyph->object)
 22572                 ? 'B'
 22573                 : (STRINGP (glyph->object)
 22574                    ? 'S'
 22575                    : (NILP (glyph->object)
 22576                       ? '0'
 22577                       : '-'))),
 22578                glyph->pixel_width,
 22579                glyph->u.ch,
 22580                (glyph->u.ch < 0x80 && glyph->u.ch >= ' '
 22581                 ? (int) glyph->u.ch
 22582                 : '.'),
 22583                glyph->face_id,
 22584                glyph->left_box_line_p,
 22585                glyph->right_box_line_p);
 22586     }
 22587   else if (glyph->type == STRETCH_GLYPH)
 22588     {
 22589       fprintf (stderr,
 22590                "  %5"pD"d     %c %9"pD"d   %c %3d 0x%06x      %c %4d %1.1d%1.1d\n",
 22591                glyph - row->glyphs[TEXT_AREA],
 22592                'S',
 22593                glyph->charpos,
 22594                (BUFFERP (glyph->object)
 22595                 ? 'B'
 22596                 : (STRINGP (glyph->object)
 22597                    ? 'S'
 22598                    : (NILP (glyph->object)
 22599                       ? '0'
 22600                       : '-'))),
 22601                glyph->pixel_width,
 22602                0u,
 22603                ' ',
 22604                glyph->face_id,
 22605                glyph->left_box_line_p,
 22606                glyph->right_box_line_p);
 22607     }
 22608   else if (glyph->type == IMAGE_GLYPH)
 22609     {
 22610       fprintf (stderr,
 22611                "  %5"pD"d     %c %9"pD"d   %c %3d 0x%06x      %c %4d %1.1d%1.1d\n",
 22612                glyph - row->glyphs[TEXT_AREA],
 22613                'I',
 22614                glyph->charpos,
 22615                (BUFFERP (glyph->object)
 22616                 ? 'B'
 22617                 : (STRINGP (glyph->object)
 22618                    ? 'S'
 22619                    : (NILP (glyph->object)
 22620                       ? '0'
 22621                       : '-'))),
 22622                glyph->pixel_width,
 22623                (unsigned int) glyph->u.img_id,
 22624                '.',
 22625                glyph->face_id,
 22626                glyph->left_box_line_p,
 22627                glyph->right_box_line_p);
 22628     }
 22629   else if (glyph->type == COMPOSITE_GLYPH)
 22630     {
 22631       fprintf (stderr,
 22632                "  %5"pD"d     %c %9"pD"d   %c %3d 0x%06x",
 22633                glyph - row->glyphs[TEXT_AREA],
 22634                '+',
 22635                glyph->charpos,
 22636                (BUFFERP (glyph->object)
 22637                 ? 'B'
 22638                 : (STRINGP (glyph->object)
 22639                    ? 'S'
 22640                    : (NILP (glyph->object)
 22641                       ? '0'
 22642                       : '-'))),
 22643                glyph->pixel_width,
 22644                (unsigned int) glyph->u.cmp.id);
 22645       if (glyph->u.cmp.automatic)
 22646         fprintf (stderr,
 22647                  "[%d-%d]",
 22648                  glyph->slice.cmp.from, glyph->slice.cmp.to);
 22649       fprintf (stderr, " . %4d %1.1d%1.1d\n",
 22650                glyph->face_id,
 22651                glyph->left_box_line_p,
 22652                glyph->right_box_line_p);
 22653     }
 22654   else if (glyph->type == XWIDGET_GLYPH)
 22655     {
 22656 #ifndef HAVE_XWIDGETS
 22657       eassume (false);
 22658 #else
 22659       fprintf (stderr,
 22660                "  %5td %4c %6td %c %3d %7p %c %4d %1.1d%1.1d\n",
 22661                glyph - row->glyphs[TEXT_AREA],
 22662                'X',
 22663                glyph->charpos,
 22664                (BUFFERP (glyph->object)
 22665                 ? 'B'
 22666                 : (STRINGP (glyph->object)
 22667                    ? 'S'
 22668                    : '-')),
 22669                glyph->pixel_width,
 22670                glyph->u.xwidget,
 22671                '.',
 22672                glyph->face_id,
 22673                glyph->left_box_line_p,
 22674                glyph->right_box_line_p);
 22675 #endif
 22676     }
 22677 }
 22678 
 22679 
 22680 /* Dump the contents of glyph row at VPOS in MATRIX to stderr.
 22681    GLYPHS 0 means don't show glyph contents.
 22682    GLYPHS 1 means show glyphs in short form
 22683    GLYPHS > 1 means show glyphs in long form.  */
 22684 
 22685 void
 22686 dump_glyph_row (struct glyph_row *row, int vpos, int glyphs)
 22687 {
 22688   if (glyphs != 1)
 22689     {
 22690       fputs (("Row     Start       End Used oE><\\CTZFesm     X    Y    W    H    V    A    P\n"
 22691               "==============================================================================\n"),
 22692              stderr);
 22693       fprintf (stderr, "%3d %9"pD"d %9"pD"d %4d %1.1d%1.1d%1.1d%1.1d\
 22694 %1.1d%1.1d%1.1d%1.1d%1.1d%1.1d%1.1d%1.1d  %4d %4d %4d %4d %4d %4d %4d\n",
 22695                vpos,
 22696                MATRIX_ROW_START_CHARPOS (row),
 22697                MATRIX_ROW_END_CHARPOS (row),
 22698                row->used[TEXT_AREA],
 22699                row->contains_overlapping_glyphs_p,
 22700                row->enabled_p,
 22701                row->truncated_on_left_p,
 22702                row->truncated_on_right_p,
 22703                row->continued_p,
 22704                MATRIX_ROW_CONTINUATION_LINE_P (row),
 22705                MATRIX_ROW_DISPLAYS_TEXT_P (row),
 22706                row->ends_at_zv_p,
 22707                row->fill_line_p,
 22708                row->ends_in_middle_of_char_p,
 22709                row->starts_in_middle_of_char_p,
 22710                row->mouse_face_p,
 22711                row->x,
 22712                row->y,
 22713                row->pixel_width,
 22714                row->height,
 22715                row->visible_height,
 22716                row->ascent,
 22717                row->phys_ascent);
 22718       /* The next 3 lines should align to "Start" in the header.  */
 22719       fprintf (stderr, "    %9"pD"d %9"pD"d\t%5d\n", row->start.overlay_string_index,
 22720                row->end.overlay_string_index,
 22721                row->continuation_lines_width);
 22722       fprintf (stderr, "    %9"pD"d %9"pD"d\n",
 22723                CHARPOS (row->start.string_pos),
 22724                CHARPOS (row->end.string_pos));
 22725       fprintf (stderr, "    %9d %9d\n", row->start.dpvec_index,
 22726                row->end.dpvec_index);
 22727     }
 22728 
 22729   if (glyphs > 1)
 22730     {
 22731       int area;
 22732 
 22733       for (area = LEFT_MARGIN_AREA; area < LAST_AREA; ++area)
 22734         {
 22735           struct glyph *glyph = row->glyphs[area];
 22736           struct glyph *glyph_end = glyph + row->used[area];
 22737 
 22738           /* Glyph for a line end in text.  */
 22739           if (area == TEXT_AREA && glyph == glyph_end && glyph->charpos > 0)
 22740             ++glyph_end;
 22741 
 22742           if (glyph < glyph_end)
 22743             fputs (" Glyph#  Type       Pos   O   W     Code      C Face LR\n",
 22744                    stderr);
 22745 
 22746           for (; glyph < glyph_end; ++glyph)
 22747             dump_glyph (row, glyph, area);
 22748         }
 22749     }
 22750   else if (glyphs == 1)
 22751     {
 22752       int area;
 22753       char s[SHRT_MAX + 4];
 22754 
 22755       for (area = LEFT_MARGIN_AREA; area < LAST_AREA; ++area)
 22756         {
 22757           int i;
 22758 
 22759           for (i = 0; i < row->used[area]; ++i)
 22760             {
 22761               struct glyph *glyph = row->glyphs[area] + i;
 22762               if (i == row->used[area] - 1
 22763                   && area == TEXT_AREA
 22764                   && NILP (glyph->object)
 22765                   && glyph->type == CHAR_GLYPH
 22766                   && glyph->u.ch == ' ')
 22767                 {
 22768                   strcpy (&s[i], "[\\n]");
 22769                   i += 4;
 22770                 }
 22771               else if (glyph->type == CHAR_GLYPH
 22772                        && glyph->u.ch < 0x80
 22773                        && glyph->u.ch >= ' ')
 22774                 s[i] = glyph->u.ch;
 22775               else
 22776                 s[i] = '.';
 22777             }
 22778 
 22779           s[i] = '\0';
 22780           fprintf (stderr, "%3d: (%d) '%s'\n", vpos, row->enabled_p, s);
 22781         }
 22782     }
 22783 }
 22784 
 22785 
 22786 DEFUN ("dump-glyph-matrix", Fdump_glyph_matrix,
 22787        Sdump_glyph_matrix, 0, 1, "p",
 22788        doc: /* Dump the current matrix of the selected window to stderr.
 22789 Shows contents of glyph row structures.  With non-nil
 22790 parameter GLYPHS, dump glyphs as well.  If GLYPHS is 1 show
 22791 glyphs in short form, otherwise show glyphs in long form.
 22792 
 22793 Interactively, no argument means show glyphs in short form;
 22794 with numeric argument, its value is passed as the GLYPHS flag.  */)
 22795   (Lisp_Object glyphs)
 22796 {
 22797   struct window *w = XWINDOW (selected_window);
 22798   struct buffer *buffer = XBUFFER (w->contents);
 22799 
 22800   fprintf (stderr, "PT = %"pD"d, BEGV = %"pD"d. ZV = %"pD"d\n",
 22801            BUF_PT (buffer), BUF_BEGV (buffer), BUF_ZV (buffer));
 22802   fprintf (stderr, "Cursor x = %d, y = %d, hpos = %d, vpos = %d\n",
 22803            w->cursor.x, w->cursor.y, w->cursor.hpos, w->cursor.vpos);
 22804   fputs ("=============================================\n", stderr);
 22805   dump_glyph_matrix (w->current_matrix,
 22806                      TYPE_RANGED_FIXNUMP (int, glyphs) ? XFIXNUM (glyphs) : 0);
 22807   return Qnil;
 22808 }
 22809 
 22810 
 22811 DEFUN ("dump-frame-glyph-matrix", Fdump_frame_glyph_matrix,
 22812        Sdump_frame_glyph_matrix, 0, 0, "", doc: /* Dump the current glyph matrix of the selected frame to stderr.
 22813 Only text-mode frames have frame glyph matrices.  */)
 22814   (void)
 22815 {
 22816   struct frame *f = XFRAME (selected_frame);
 22817 
 22818   if (f->current_matrix)
 22819     dump_glyph_matrix (f->current_matrix, 1);
 22820   else
 22821     fputs ("*** This frame doesn't have a frame glyph matrix ***\n", stderr);
 22822   return Qnil;
 22823 }
 22824 
 22825 
 22826 DEFUN ("dump-glyph-row", Fdump_glyph_row, Sdump_glyph_row, 1, 2, "P",
 22827        doc: /* Dump glyph row ROW to stderr.
 22828 Interactively, ROW is the prefix numeric argument and defaults to
 22829 the row which displays point.
 22830 Optional argument GLYPHS 0 means don't dump glyphs.
 22831 GLYPHS 1 means dump glyphs in short form.
 22832 GLYPHS > 1 or omitted means dump glyphs in long form.  */)
 22833   (Lisp_Object row, Lisp_Object glyphs)
 22834 {
 22835   struct glyph_matrix *matrix;
 22836   EMACS_INT vpos;
 22837 
 22838   if (NILP (row))
 22839     {
 22840       int d1, d2, d3, d4, d5, ypos;
 22841       bool visible_p = pos_visible_p (XWINDOW (selected_window), PT,
 22842                                       &d1, &d2, &d3, &d4, &d5, &ypos);
 22843       if (visible_p)
 22844         vpos = ypos;
 22845       else
 22846         vpos = 0;
 22847     }
 22848   else
 22849     {
 22850       CHECK_FIXNUM (row);
 22851       vpos = XFIXNUM (row);
 22852     }
 22853   matrix = XWINDOW (selected_window)->current_matrix;
 22854   if (vpos >= 0 && vpos < matrix->nrows)
 22855     dump_glyph_row (MATRIX_ROW (matrix, vpos),
 22856                     vpos,
 22857                     TYPE_RANGED_FIXNUMP (int, glyphs) ? XFIXNUM (glyphs) : 2);
 22858   return Qnil;
 22859 }
 22860 
 22861 
 22862 DEFUN ("dump-tab-bar-row", Fdump_tab_bar_row, Sdump_tab_bar_row, 1, 2, "P",
 22863        doc: /* Dump glyph row ROW of the tab-bar of the current frame to stderr.
 22864 Interactively, ROW is the prefix numeric argument and defaults to zero.
 22865 GLYPHS 0 means don't dump glyphs.
 22866 GLYPHS 1 means dump glyphs in short form.
 22867 GLYPHS > 1 or omitted means dump glyphs in long form.
 22868 
 22869 If there's no tab-bar, or if the tab-bar is not drawn by Emacs,
 22870 do nothing.  */)
 22871   (Lisp_Object row, Lisp_Object glyphs)
 22872 {
 22873 #if defined (HAVE_WINDOW_SYSTEM)
 22874   struct frame *sf = SELECTED_FRAME ();
 22875   struct glyph_matrix *m = WINDOWP (sf->tab_bar_window)
 22876     ? XWINDOW (sf->tab_bar_window)->current_matrix
 22877     : sf->current_matrix;
 22878   EMACS_INT vpos;
 22879 
 22880   if (NILP (row))
 22881     vpos = WINDOWP (sf->tab_bar_window) ? 0 :
 22882       FRAME_MENU_BAR_LINES (sf) > 0 ? 1 : 0;
 22883   else
 22884     {
 22885       CHECK_FIXNUM (row);
 22886       vpos = XFIXNUM (row);
 22887     }
 22888   if (vpos >= 0 && vpos < m->nrows)
 22889     dump_glyph_row (MATRIX_ROW (m, vpos), vpos,
 22890                     TYPE_RANGED_FIXNUMP (int, glyphs) ? XFIXNUM (glyphs) : 2);
 22891 #endif
 22892   return Qnil;
 22893 }
 22894 
 22895 DEFUN ("dump-tool-bar-row", Fdump_tool_bar_row, Sdump_tool_bar_row, 1, 2, "P",
 22896        doc: /* Dump glyph row ROW of the tool-bar of the current frame to stderr.
 22897 Interactively, ROW is the prefix numeric argument and defaults to zero.
 22898 GLYPHS 0 means don't dump glyphs.
 22899 GLYPHS 1 means dump glyphs in short form.
 22900 GLYPHS > 1 or omitted means dump glyphs in long form.
 22901 
 22902 If there's no tool-bar, or if the tool-bar is not drawn by Emacs,
 22903 do nothing.  */)
 22904   (Lisp_Object row, Lisp_Object glyphs)
 22905 {
 22906 #if defined (HAVE_WINDOW_SYSTEM) && ! defined (HAVE_EXT_TOOL_BAR)
 22907   struct frame *sf = SELECTED_FRAME ();
 22908   struct glyph_matrix *m = XWINDOW (sf->tool_bar_window)->current_matrix;
 22909   EMACS_INT vpos;
 22910 
 22911   if (NILP (row))
 22912     vpos = 0;
 22913   else
 22914     {
 22915       CHECK_FIXNUM (row);
 22916       vpos = XFIXNUM (row);
 22917     }
 22918   if (vpos >= 0 && vpos < m->nrows)
 22919     dump_glyph_row (MATRIX_ROW (m, vpos), vpos,
 22920                     TYPE_RANGED_FIXNUMP (int, glyphs) ? XFIXNUM (glyphs) : 2);
 22921 #endif
 22922   return Qnil;
 22923 }
 22924 
 22925 
 22926 DEFUN ("trace-redisplay", Ftrace_redisplay, Strace_redisplay, 0, 1, "P",
 22927        doc: /* Toggle tracing of redisplay.
 22928 With ARG, turn tracing on if and only if ARG is positive.  */)
 22929   (Lisp_Object arg)
 22930 {
 22931   if (NILP (arg))
 22932     trace_redisplay_p = !trace_redisplay_p;
 22933   else
 22934     {
 22935       arg = Fprefix_numeric_value (arg);
 22936       trace_redisplay_p = XFIXNUM (arg) > 0;
 22937     }
 22938 
 22939   return Qnil;
 22940 }
 22941 
 22942 
 22943 DEFUN ("trace-to-stderr", Ftrace_to_stderr, Strace_to_stderr, 1, MANY, "",
 22944        doc: /* Like `format', but print result to stderr.
 22945 usage: (trace-to-stderr STRING &rest OBJECTS)  */)
 22946   (ptrdiff_t nargs, Lisp_Object *args)
 22947 {
 22948   Lisp_Object s = Fformat (nargs, args);
 22949   fwrite (SDATA (s), 1, SBYTES (s), stderr);
 22950   return Qnil;
 22951 }
 22952 
 22953 #endif /* GLYPH_DEBUG */
 22954 
 22955 
 22956 
 22957 /***********************************************************************
 22958                      Building Desired Matrix Rows
 22959  ***********************************************************************/
 22960 
 22961 /* Return a temporary glyph row holding the glyphs of an overlay arrow.
 22962    Used for non-window-redisplay windows, and for windows without left
 22963    fringe.  */
 22964 
 22965 static struct glyph_row *
 22966 get_overlay_arrow_glyph_row (struct window *w, Lisp_Object overlay_arrow_string)
 22967 {
 22968   struct frame *f = XFRAME (WINDOW_FRAME (w));
 22969   struct buffer *buffer = XBUFFER (w->contents);
 22970   struct buffer *old = current_buffer;
 22971   const unsigned char *arrow_string = SDATA (overlay_arrow_string);
 22972   ptrdiff_t arrow_len = SBYTES (overlay_arrow_string), char_num = 0;
 22973   const unsigned char *arrow_end = arrow_string + arrow_len;
 22974   const unsigned char *p;
 22975   struct it it;
 22976   bool multibyte_p;
 22977   int n_glyphs_before;
 22978 
 22979   set_buffer_temp (buffer);
 22980   init_iterator (&it, w, -1, -1, &scratch_glyph_row, DEFAULT_FACE_ID);
 22981   scratch_glyph_row.reversed_p = false;
 22982   it.glyph_row->used[TEXT_AREA] = 0;
 22983   SET_TEXT_POS (it.position, 0, 0);
 22984 
 22985   multibyte_p = !NILP (BVAR (buffer, enable_multibyte_characters));
 22986   p = arrow_string;
 22987   while (p < arrow_end)
 22988     {
 22989       Lisp_Object face, ilisp;
 22990 
 22991       /* Get the next character.  */
 22992       if (multibyte_p)
 22993         it.c = it.char_to_display = check_char_and_length (p, &it.len);
 22994       else
 22995         {
 22996           it.c = it.char_to_display = *p, it.len = 1;
 22997           if (! ASCII_CHAR_P (it.c))
 22998             it.char_to_display = BYTE8_TO_CHAR (it.c);
 22999         }
 23000       p += it.len;
 23001 
 23002       /* Get its face.  */
 23003       ilisp = make_fixnum (char_num++);
 23004       face = Fget_text_property (ilisp, Qface, overlay_arrow_string);
 23005       it.face_id = compute_char_face (f, it.char_to_display, face);
 23006 
 23007       /* Compute its width, get its glyphs.  */
 23008       n_glyphs_before = it.glyph_row->used[TEXT_AREA];
 23009       SET_TEXT_POS (it.position, -1, -1);
 23010       PRODUCE_GLYPHS (&it);
 23011 
 23012       /* If this character doesn't fit any more in the line, we have
 23013          to remove some glyphs.  */
 23014       if (it.current_x > it.last_visible_x)
 23015         {
 23016           it.glyph_row->used[TEXT_AREA] = n_glyphs_before;
 23017           break;
 23018         }
 23019     }
 23020 
 23021   set_buffer_temp (old);
 23022   return it.glyph_row;
 23023 }
 23024 
 23025 
 23026 /* Insert truncation glyphs at the start of IT->glyph_row.  Which
 23027    glyphs to insert is determined by produce_special_glyphs.  */
 23028 
 23029 static void
 23030 insert_left_trunc_glyphs (struct it *it)
 23031 {
 23032   struct it truncate_it;
 23033   struct glyph *from, *end, *to, *toend;
 23034 
 23035   eassert (!FRAME_WINDOW_P (it->f)
 23036            || (!it->glyph_row->reversed_p
 23037                && WINDOW_LEFT_FRINGE_WIDTH (it->w) == 0)
 23038            || (it->glyph_row->reversed_p
 23039                && WINDOW_RIGHT_FRINGE_WIDTH (it->w) == 0));
 23040 
 23041   /* Get the truncation glyphs.  */
 23042   truncate_it = *it;
 23043   truncate_it.current_x = 0;
 23044   truncate_it.face_id = DEFAULT_FACE_ID;
 23045   truncate_it.glyph_row = &scratch_glyph_row;
 23046   truncate_it.area = TEXT_AREA;
 23047   truncate_it.glyph_row->used[TEXT_AREA] = 0;
 23048   CHARPOS (truncate_it.position) = BYTEPOS (truncate_it.position) = -1;
 23049   truncate_it.object = Qnil;
 23050   produce_special_glyphs (&truncate_it, IT_TRUNCATION);
 23051 
 23052   /* Overwrite glyphs from IT with truncation glyphs.  */
 23053   if (!it->glyph_row->reversed_p)
 23054     {
 23055       short tused = truncate_it.glyph_row->used[TEXT_AREA];
 23056 
 23057       from = truncate_it.glyph_row->glyphs[TEXT_AREA];
 23058       end = from + tused;
 23059       to = it->glyph_row->glyphs[TEXT_AREA];
 23060       toend = to + it->glyph_row->used[TEXT_AREA];
 23061       if (FRAME_WINDOW_P (it->f))
 23062         {
 23063           /* On GUI frames, when variable-size fonts are displayed,
 23064              the truncation glyphs may need more pixels than the row's
 23065              glyphs they overwrite.  We overwrite more glyphs to free
 23066              enough screen real estate, and enlarge the stretch glyph
 23067              on the right (see display_line), if there is one, to
 23068              preserve the screen position of the truncation glyphs on
 23069              the right.  */
 23070           int w = 0;
 23071           struct glyph *g = to;
 23072           short used;
 23073 
 23074           /* The first glyph could be partially visible, in which case
 23075              it->glyph_row->x will be negative.  But we want the left
 23076              truncation glyphs to be aligned at the left margin of the
 23077              window, so we override the x coordinate at which the row
 23078              will begin.  */
 23079           it->glyph_row->x = 0;
 23080           while (g < toend && w < it->truncation_pixel_width)
 23081             {
 23082               w += g->pixel_width;
 23083               ++g;
 23084             }
 23085           if (g - to - tused > 0)
 23086             {
 23087               memmove (to + tused, g, (toend - g) * sizeof(*g));
 23088               it->glyph_row->used[TEXT_AREA] -= g - to - tused;
 23089             }
 23090           used = it->glyph_row->used[TEXT_AREA];
 23091           if (it->glyph_row->truncated_on_right_p
 23092               && WINDOW_RIGHT_FRINGE_WIDTH (it->w) == 0
 23093               && it->glyph_row->glyphs[TEXT_AREA][used - 2].type
 23094               == STRETCH_GLYPH)
 23095             {
 23096               int extra = w - it->truncation_pixel_width;
 23097 
 23098               it->glyph_row->glyphs[TEXT_AREA][used - 2].pixel_width += extra;
 23099             }
 23100         }
 23101 
 23102       while (from < end)
 23103         *to++ = *from++;
 23104 
 23105       /* There may be padding glyphs left over.  Overwrite them too.  */
 23106       if (!FRAME_WINDOW_P (it->f))
 23107         {
 23108           while (to < toend && CHAR_GLYPH_PADDING_P (*to))
 23109             {
 23110               from = truncate_it.glyph_row->glyphs[TEXT_AREA];
 23111               while (from < end)
 23112                 *to++ = *from++;
 23113             }
 23114         }
 23115 
 23116       if (to > toend)
 23117         it->glyph_row->used[TEXT_AREA] = to - it->glyph_row->glyphs[TEXT_AREA];
 23118     }
 23119   else
 23120     {
 23121       short tused = truncate_it.glyph_row->used[TEXT_AREA];
 23122 
 23123       /* In R2L rows, overwrite the last (rightmost) glyphs, and do
 23124          that back to front.  */
 23125       end = truncate_it.glyph_row->glyphs[TEXT_AREA];
 23126       from = end + truncate_it.glyph_row->used[TEXT_AREA] - 1;
 23127       toend = it->glyph_row->glyphs[TEXT_AREA];
 23128       to = toend + it->glyph_row->used[TEXT_AREA] - 1;
 23129       if (FRAME_WINDOW_P (it->f))
 23130         {
 23131           int w = 0;
 23132           struct glyph *g = to;
 23133 
 23134           while (g >= toend && w < it->truncation_pixel_width)
 23135             {
 23136               w += g->pixel_width;
 23137               --g;
 23138             }
 23139           if (to - g - tused > 0)
 23140             to = g + tused;
 23141           if (it->glyph_row->truncated_on_right_p
 23142               && WINDOW_LEFT_FRINGE_WIDTH (it->w) == 0
 23143               && it->glyph_row->glyphs[TEXT_AREA][1].type == STRETCH_GLYPH)
 23144             {
 23145               int extra = w - it->truncation_pixel_width;
 23146 
 23147               it->glyph_row->glyphs[TEXT_AREA][1].pixel_width += extra;
 23148             }
 23149         }
 23150 
 23151       while (from >= end && to >= toend)
 23152         *to-- = *from--;
 23153       if (!FRAME_WINDOW_P (it->f))
 23154         {
 23155           while (to >= toend && CHAR_GLYPH_PADDING_P (*to))
 23156             {
 23157               from =
 23158                 truncate_it.glyph_row->glyphs[TEXT_AREA]
 23159                 + truncate_it.glyph_row->used[TEXT_AREA] - 1;
 23160               while (from >= end && to >= toend)
 23161                 *to-- = *from--;
 23162             }
 23163         }
 23164       if (from >= end)
 23165         {
 23166           /* Need to free some room before prepending additional
 23167              glyphs.  */
 23168           int move_by = from - end + 1;
 23169           struct glyph *g0 = it->glyph_row->glyphs[TEXT_AREA];
 23170           struct glyph *g = g0 + it->glyph_row->used[TEXT_AREA] - 1;
 23171 
 23172           for ( ; g >= g0; g--)
 23173             g[move_by] = *g;
 23174           while (from >= end)
 23175             *to-- = *from--;
 23176           it->glyph_row->used[TEXT_AREA] += move_by;
 23177         }
 23178     }
 23179 }
 23180 
 23181 /* Compute the hash code for ROW.  */
 23182 unsigned
 23183 row_hash (struct glyph_row *row)
 23184 {
 23185   int area, k;
 23186   unsigned hashval = 0;
 23187 
 23188   for (area = LEFT_MARGIN_AREA; area < LAST_AREA; ++area)
 23189     for (k = 0; k < row->used[area]; ++k)
 23190       hashval = ((((hashval << 4) + (hashval >> 24)) & 0x0fffffff)
 23191                   + row->glyphs[area][k].u.val
 23192                   + row->glyphs[area][k].face_id
 23193                   + row->glyphs[area][k].padding_p
 23194                   + (row->glyphs[area][k].type << 2));
 23195 
 23196   return hashval;
 23197 }
 23198 
 23199 /* Compute the pixel height and width of IT->glyph_row.
 23200 
 23201    Most of the time, ascent and height of a display line will be equal
 23202    to the max_ascent and max_height values of the display iterator
 23203    structure.  This is not the case if
 23204 
 23205    1. We hit ZV without displaying anything.  In this case, max_ascent
 23206    and max_height will be zero.
 23207 
 23208    2. We have some glyphs that don't contribute to the line height.
 23209    (The glyph row flag contributes_to_line_height_p is for future
 23210    pixmap extensions).
 23211 
 23212    The first case is easily covered by using default values because in
 23213    these cases, the line height does not really matter, except that it
 23214    must not be zero.  */
 23215 
 23216 static void
 23217 compute_line_metrics (struct it *it)
 23218 {
 23219   struct glyph_row *row = it->glyph_row;
 23220 
 23221   if (FRAME_WINDOW_P (it->f))
 23222     {
 23223       int i, min_y, max_y;
 23224 
 23225       /* The line may consist of one space only, that was added to
 23226          place the cursor on it.  If so, the row's height hasn't been
 23227          computed yet.  */
 23228       if (row->height == 0)
 23229         {
 23230           if (it->max_ascent + it->max_descent == 0)
 23231             it->max_descent = it->max_phys_descent = FRAME_LINE_HEIGHT (it->f);
 23232           row->ascent = it->max_ascent;
 23233           row->height = it->max_ascent + it->max_descent;
 23234           row->phys_ascent = it->max_phys_ascent;
 23235           row->phys_height = it->max_phys_ascent + it->max_phys_descent;
 23236           row->extra_line_spacing = it->max_extra_line_spacing;
 23237         }
 23238 
 23239       /* Compute the width of this line.  */
 23240       row->pixel_width = row->x;
 23241       for (i = 0; i < row->used[TEXT_AREA]; ++i)
 23242         row->pixel_width += row->glyphs[TEXT_AREA][i].pixel_width;
 23243 
 23244       eassert (row->pixel_width >= 0);
 23245       eassert (row->ascent >= 0 && row->height > 0);
 23246 
 23247       row->overlapping_p = (MATRIX_ROW_OVERLAPS_SUCC_P (row)
 23248                             || MATRIX_ROW_OVERLAPS_PRED_P (row));
 23249 
 23250       /* If first line's physical ascent is larger than its logical
 23251          ascent, use the physical ascent, and make the row taller.
 23252          This makes accented characters fully visible.  */
 23253       if (row == MATRIX_FIRST_TEXT_ROW (it->w->desired_matrix)
 23254           && row->phys_ascent > row->ascent)
 23255         {
 23256           row->height += row->phys_ascent - row->ascent;
 23257           row->ascent = row->phys_ascent;
 23258         }
 23259 
 23260       /* Compute how much of the line is visible.  */
 23261       row->visible_height = row->height;
 23262 
 23263       min_y = WINDOW_TAB_LINE_HEIGHT (it->w) + WINDOW_HEADER_LINE_HEIGHT (it->w);
 23264       max_y = WINDOW_BOX_HEIGHT_NO_MODE_LINE (it->w);
 23265 
 23266       if (row->y < min_y)
 23267         row->visible_height -= min_y - row->y;
 23268       if (row->y + row->height > max_y)
 23269         row->visible_height -= row->y + row->height - max_y;
 23270     }
 23271   else
 23272     {
 23273       row->pixel_width = row->used[TEXT_AREA];
 23274       if (row->continued_p)
 23275         row->pixel_width -= it->continuation_pixel_width;
 23276       else if (row->truncated_on_right_p)
 23277         row->pixel_width -= it->truncation_pixel_width;
 23278       row->ascent = row->phys_ascent = 0;
 23279       row->height = row->phys_height = row->visible_height = 1;
 23280       row->extra_line_spacing = 0;
 23281     }
 23282 
 23283   /* Compute a hash code for this row.  */
 23284   row->hash = row_hash (row);
 23285 
 23286   it->max_ascent = it->max_descent = 0;
 23287   it->max_phys_ascent = it->max_phys_descent = 0;
 23288 }
 23289 
 23290 
 23291 static void
 23292 clear_position (struct it *it)
 23293 {
 23294   it->position.charpos = 0;
 23295   it->position.bytepos = 0;
 23296 }
 23297 
 23298 /* Append one space to the glyph row of iterator IT if doing a
 23299    window-based redisplay.  The space has the same face as
 23300    IT->face_id.  Value is true if a space was added.
 23301 
 23302    This function is called to make sure that there is always one glyph
 23303    at the end of a glyph row that the cursor can be set on under
 23304    window-systems.  (If there weren't such a glyph we would not know
 23305    how wide and tall a box cursor should be displayed).
 23306 
 23307    At the same time this space let's a nicely handle clearing to the
 23308    end of the line if the row ends in italic text.  */
 23309 
 23310 static bool
 23311 append_space_for_newline (struct it *it, bool default_face_p)
 23312 {
 23313   int n = it->glyph_row->used[TEXT_AREA];
 23314 
 23315   if (it->glyph_row->glyphs[TEXT_AREA] + n
 23316       < it->glyph_row->glyphs[1 + TEXT_AREA])
 23317     {
 23318       /* Save some values that must not be changed.
 23319          Must save IT->c and IT->len because otherwise
 23320          ITERATOR_AT_END_P wouldn't work anymore after
 23321          append_space_for_newline has been called.  */
 23322       enum display_element_type saved_what = it->what;
 23323       int saved_c = it->c, saved_len = it->len;
 23324       int saved_char_to_display = it->char_to_display;
 23325       int saved_x = it->current_x;
 23326       const int saved_face_id = it->face_id;
 23327       bool saved_box_end = it->end_of_box_run_p;
 23328       struct text_pos saved_pos = it->position;
 23329       Lisp_Object saved_object = it->object;
 23330       struct face *face;
 23331 
 23332       it->what = IT_CHARACTER;
 23333       clear_position (it);
 23334       it->object = Qnil;
 23335       it->len = 1;
 23336 
 23337       int char_width = 1;
 23338 
 23339       if (default_face_p
 23340 #ifdef HAVE_WINDOW_SYSTEM
 23341           || FRAME_WINDOW_P (it->f)
 23342 #endif
 23343           )
 23344         {
 23345           const int local_default_face_id =
 23346             lookup_basic_face (it->w, it->f, DEFAULT_FACE_ID);
 23347 
 23348 #ifdef HAVE_WINDOW_SYSTEM
 23349           if (FRAME_WINDOW_P (it->f))
 23350             {
 23351               struct face *default_face
 23352                 = FACE_FROM_ID (it->f, local_default_face_id);
 23353               struct font *font = (default_face->font
 23354                                    ? default_face->font
 23355                                    : FRAME_FONT (it->f));
 23356               char_width = (font->average_width
 23357                             ? font->average_width
 23358                             : font->space_width);
 23359             }
 23360 #endif
 23361           if (default_face_p)
 23362             it->face_id = local_default_face_id;
 23363         }
 23364       /* Corner case for when display-fill-column-indicator-mode
 23365          is active and the extra character should be added in the
 23366          same place than the line.  */
 23367 
 23368       const int indicator_column =
 23369         fill_column_indicator_column (it, char_width);
 23370       int saved_end_of_box_run = it->end_of_box_run_p;
 23371       bool should_keep_end_of_box_run = false;
 23372 
 23373       if (it->current_x == indicator_column)
 23374         {
 23375           it->c = it->char_to_display
 23376             = XFIXNAT (Vdisplay_fill_column_indicator_character);
 23377           it->face_id
 23378             = merge_faces (it->w, Qfill_column_indicator,
 23379                            0, saved_face_id);
 23380           face = FACE_FROM_ID (it->f, it->face_id);
 23381         }
 23382       else
 23383         {
 23384           it->c = it->char_to_display = ' ';
 23385           /* If the default face was remapped, be sure to use the
 23386              remapped face for the appended newline.  */
 23387 
 23388           face = FACE_FROM_ID (it->f, it->face_id);
 23389           it->face_id = FACE_FOR_CHAR (it->f, face, 0, -1, Qnil);
 23390           /* In R2L rows, we will prepend a stretch glyph that will
 23391              have the end_of_box_run_p flag set for it, so there's no
 23392              need for the appended newline glyph to have that flag
 23393              set.  */
 23394           if (!(it->glyph_row->reversed_p
 23395                 /* But if the appended newline glyph goes all the way to
 23396                    the end of the row, there will be no stretch glyph,
 23397                    so leave the box flag set.  */
 23398                 && saved_x + FRAME_COLUMN_WIDTH (it->f) < it->last_visible_x))
 23399             should_keep_end_of_box_run = true;
 23400         }
 23401       PRODUCE_GLYPHS (it);
 23402       /* Restore the end_of_box_run_p flag which was reset by
 23403          PRODUCE_GLYPHS.  */
 23404       if (should_keep_end_of_box_run)
 23405         it->end_of_box_run_p = saved_end_of_box_run;
 23406 #ifdef HAVE_WINDOW_SYSTEM
 23407       if (FRAME_WINDOW_P (it->f))
 23408         {
 23409           /* Make sure this space glyph has the right ascent and
 23410              descent values, or else cursor at end of line will look
 23411              funny, and height of empty lines will be incorrect.  */
 23412           struct glyph *g = it->glyph_row->glyphs[TEXT_AREA] + n;
 23413           struct font *font = face->font ? face->font : FRAME_FONT (it->f);
 23414           if (n == 0)
 23415             {
 23416               Lisp_Object height, total_height;
 23417               int extra_line_spacing = it->extra_line_spacing;
 23418               int boff = font->baseline_offset;
 23419 
 23420               if (font->vertical_centering)
 23421                 boff = VCENTER_BASELINE_OFFSET (font, it->f) - boff;
 23422 
 23423               it->object = saved_object; /* get_it_property needs this */
 23424               normal_char_ascent_descent (font, -1, &it->ascent, &it->descent);
 23425               /* Must do a subset of line height processing from
 23426                  gui_produce_glyph for newline characters.  */
 23427               height = get_it_property (it, Qline_height);
 23428               if (CONSP (height)
 23429                   && CONSP (XCDR (height))
 23430                   && NILP (XCDR (XCDR (height))))
 23431                 {
 23432                   total_height = XCAR (XCDR (height));
 23433                   height = XCAR (height);
 23434                 }
 23435               else
 23436                 total_height = Qnil;
 23437               height = calc_line_height_property (it, height, font, boff, true);
 23438 
 23439               if (it->override_ascent >= 0)
 23440                 {
 23441                   it->ascent = it->override_ascent;
 23442                   it->descent = it->override_descent;
 23443                   boff = it->override_boff;
 23444                 }
 23445               if (EQ (height, Qt))
 23446                 extra_line_spacing = 0;
 23447               else
 23448                 {
 23449                   Lisp_Object spacing;
 23450 
 23451                   it->phys_ascent = it->ascent;
 23452                   it->phys_descent = it->descent;
 23453                   if (!NILP (height)
 23454                       && XFIXNUM (height) > it->ascent + it->descent)
 23455                     it->ascent = XFIXNUM (height) - it->descent;
 23456 
 23457                   if (!NILP (total_height))
 23458                     spacing = calc_line_height_property (it, total_height, font,
 23459                                                          boff, false);
 23460                   else
 23461                     {
 23462                       spacing = get_it_property (it, Qline_spacing);
 23463                       spacing = calc_line_height_property (it, spacing, font,
 23464                                                            boff, false);
 23465                     }
 23466                   if (FIXNUMP (spacing))
 23467                     {
 23468                       extra_line_spacing = XFIXNUM (spacing);
 23469                       if (!NILP (total_height))
 23470                         extra_line_spacing -= (it->phys_ascent + it->phys_descent);
 23471                     }
 23472                 }
 23473               if (extra_line_spacing > 0)
 23474                 {
 23475                   it->descent += extra_line_spacing;
 23476                   if (extra_line_spacing > it->max_extra_line_spacing)
 23477                     it->max_extra_line_spacing = extra_line_spacing;
 23478                 }
 23479               it->max_ascent = it->ascent;
 23480               it->max_descent = it->descent;
 23481               /* Make sure compute_line_metrics recomputes the row height.  */
 23482               it->glyph_row->height = 0;
 23483             }
 23484 
 23485           g->ascent = it->max_ascent;
 23486           g->descent = it->max_descent;
 23487         }
 23488 #endif /* HAVE_WINDOW_SYSTEM  */
 23489       it->override_ascent = -1;
 23490       it->constrain_row_ascent_descent_p = false;
 23491       it->current_x = saved_x;
 23492       it->object = saved_object;
 23493       it->position = saved_pos;
 23494       it->what = saved_what;
 23495       it->face_id = saved_face_id;
 23496       it->len = saved_len;
 23497       it->c = saved_c;
 23498       it->char_to_display = saved_char_to_display;
 23499       it->end_of_box_run_p = saved_box_end;
 23500       return true;
 23501     }
 23502 
 23503   return false;
 23504 }
 23505 
 23506 
 23507 /* Extend the face of the last glyph in the text area of IT->glyph_row
 23508    to the end of the display line.  Called from display_line.  If the
 23509    glyph row is empty, add a space glyph to it so that we know the
 23510    face to draw.  Set the glyph row flag fill_line_p.  If the glyph
 23511    row is R2L, prepend a stretch glyph to cover the empty space to the
 23512    left of the leftmost glyph.  */
 23513 
 23514 static void
 23515 extend_face_to_end_of_line (struct it *it)
 23516 {
 23517   struct frame *f = it->f;
 23518 
 23519   /* If line is already filled, do nothing.  Non window-system frames
 23520      get a grace of one more ``pixel'' because their characters are
 23521      1-``pixel'' wide, so they hit the equality too early.  This grace
 23522      is needed only for R2L rows that are not continued, to produce
 23523      one extra blank where we could display the cursor.  */
 23524   if ((it->current_x >= it->last_visible_x
 23525        + (!FRAME_WINDOW_P (f)
 23526           && it->glyph_row->reversed_p
 23527           && !it->glyph_row->continued_p))
 23528       /* If the window has display margins, we will need to extend
 23529          their face even if the text area is filled.  */
 23530       && !(WINDOW_LEFT_MARGIN_WIDTH (it->w) > 0
 23531            || WINDOW_RIGHT_MARGIN_WIDTH (it->w) > 0))
 23532     return;
 23533 
 23534   specpdl_ref count = SPECPDL_INDEX ();
 23535 
 23536   /* Don't allow the user to quit out of face-merging code, in case
 23537      this is called when redisplaying a non-selected window, with
 23538      point temporarily moved to window-point.  */
 23539   specbind (Qinhibit_quit, Qt);
 23540   /* The default face, possibly remapped. */
 23541   struct face *default_face =
 23542     FACE_FROM_ID_OR_NULL (f, lookup_basic_face (it->w, f, DEFAULT_FACE_ID));
 23543   if (!default_face)
 23544     return;
 23545 
 23546   const int extend_face_id =
 23547     (it->face_id == default_face->id || it->s != NULL)
 23548     ? it->face_id
 23549     : (it->glyph_row->ends_at_zv_p
 23550        ? default_face->id
 23551        : face_at_pos (it, LFACE_EXTEND_INDEX));
 23552   unbind_to (count, Qnil);
 23553 
 23554   /* Face extension extends the background and box of IT->extend_face_id
 23555      to the end of the line.  If the background equals the background
 23556      of the frame, we don't have to do anything.  */
 23557   struct face *face = FACE_FROM_ID (f, (it->face_before_selective_p
 23558                                         ? it->saved_face_id
 23559                                         : extend_face_id));
 23560 
 23561   if (FRAME_WINDOW_P (f)
 23562       && MATRIX_ROW_DISPLAYS_TEXT_P (it->glyph_row)
 23563       && face->box == FACE_NO_BOX
 23564       && face->underline == FACE_NO_UNDERLINE
 23565       && !face->overline_p
 23566       && !face->strike_through_p
 23567       && face->background == FRAME_BACKGROUND_PIXEL (f)
 23568 #ifdef HAVE_WINDOW_SYSTEM
 23569       && !face->stipple
 23570 #endif
 23571       && !it->glyph_row->reversed_p
 23572       && !display_fill_column_indicator)
 23573     return;
 23574 
 23575   /* Set the glyph row flag indicating that the face of the last glyph
 23576      in the text area has to be drawn to the end of the text area.  */
 23577   it->glyph_row->fill_line_p = true;
 23578 
 23579   const int orig_face_id = it->face_id;
 23580   /* If current character of IT is not ASCII, make sure we have the
 23581      ASCII face.  This will be automatically undone the next time
 23582      get_next_display_element returns a multibyte character.  Note
 23583      that the character will always be single byte in unibyte
 23584      text.  */
 23585   if (!ASCII_CHAR_P (it->c))
 23586     it->face_id = FACE_FOR_CHAR (f, face, 0, -1, Qnil);
 23587 
 23588 
 23589 #ifdef HAVE_WINDOW_SYSTEM
 23590   if (FRAME_WINDOW_P (f))
 23591     {
 23592       /* If the row is empty, add a space with the current face of IT,
 23593          so that we know which face to draw.  */
 23594       if (it->glyph_row->used[TEXT_AREA] == 0)
 23595         {
 23596           it->glyph_row->glyphs[TEXT_AREA][0] = space_glyph;
 23597           it->glyph_row->glyphs[TEXT_AREA][0].face_id = face->id;
 23598           it->glyph_row->used[TEXT_AREA] = 1;
 23599         }
 23600       /* Mode line and the header line don't have margins, and
 23601          likewise the frame's tool-bar window, if there is any.  */
 23602       if (!(it->glyph_row->mode_line_p
 23603             || (WINDOWP (f->tab_bar_window)
 23604                 && it->w == XWINDOW (f->tab_bar_window))
 23605 #ifndef HAVE_EXT_TOOL_BAR
 23606             || (WINDOWP (f->tool_bar_window)
 23607                 && it->w == XWINDOW (f->tool_bar_window))
 23608 #endif
 23609             ))
 23610         {
 23611           if (WINDOW_LEFT_MARGIN_WIDTH (it->w) > 0
 23612               && it->glyph_row->used[LEFT_MARGIN_AREA] == 0)
 23613             {
 23614               it->glyph_row->glyphs[LEFT_MARGIN_AREA][0] = space_glyph;
 23615               it->glyph_row->glyphs[LEFT_MARGIN_AREA][0].face_id =
 23616                 default_face->id;
 23617               it->glyph_row->used[LEFT_MARGIN_AREA] = 1;
 23618             }
 23619           if (WINDOW_RIGHT_MARGIN_WIDTH (it->w) > 0
 23620               && it->glyph_row->used[RIGHT_MARGIN_AREA] == 0)
 23621             {
 23622               it->glyph_row->glyphs[RIGHT_MARGIN_AREA][0] = space_glyph;
 23623               it->glyph_row->glyphs[RIGHT_MARGIN_AREA][0].face_id =
 23624                 default_face->id;
 23625               it->glyph_row->used[RIGHT_MARGIN_AREA] = 1;
 23626             }
 23627 
 23628           struct font *font = (default_face->font
 23629                                ? default_face->font
 23630                                : FRAME_FONT (f));
 23631 
 23632           const int char_width = (font->average_width
 23633                                   ? font->average_width
 23634                                   : font->space_width);
 23635 
 23636           const int indicator_column =
 23637             fill_column_indicator_column (it, char_width);
 23638 
 23639           const char saved_char = it->char_to_display;
 23640           const struct text_pos saved_pos = it->position;
 23641           const bool saved_avoid_cursor = it->avoid_cursor_p;
 23642           const bool saved_box_start = it->start_of_box_run_p;
 23643           Lisp_Object save_object = it->object;
 23644           const int saved_face_id = it->face_id;
 23645 
 23646           it->face_id = extend_face_id;
 23647           it->avoid_cursor_p = true;
 23648           it->object = Qnil;
 23649 
 23650           const int stretch_height = it->ascent + it->descent;
 23651           const int stretch_ascent =
 23652             (stretch_height * FONT_BASE (font)) / FONT_HEIGHT (font);
 23653 
 23654           if (indicator_column >= 0
 23655               && indicator_column > it->current_x
 23656               && indicator_column < it->last_visible_x)
 23657             {
 23658 
 23659               /* Here we subtract char_width because we want the
 23660                  column indicator in the column INDICATOR_COLUMN,
 23661                  not after it.  */
 23662               const int stretch_width =
 23663                 indicator_column - it->current_x - char_width;
 23664 
 23665               clear_position (it);
 23666 
 23667               /* Only generate a stretch glyph if there is distance
 23668                  between current_x and the indicator position.  */
 23669               if (stretch_width > 0)
 23670                 {
 23671                   append_stretch_glyph (it, Qnil, stretch_width,
 23672                                         stretch_height, stretch_ascent);
 23673                 }
 23674 
 23675               /* Generate the glyph indicator only if
 23676                  append_space_for_newline didn't already.  */
 23677               if (it->current_x < indicator_column)
 23678                 {
 23679                   const int save_face_id = it->face_id;
 23680                   const int save_ascent = it->ascent;
 23681                   const int save_descent = it->descent;
 23682                   it->char_to_display
 23683                     = XFIXNAT (Vdisplay_fill_column_indicator_character);
 23684                   it->face_id
 23685                     = merge_faces (it->w, Qfill_column_indicator,
 23686                                    0, extend_face_id);
 23687                   PRODUCE_GLYPHS (it);
 23688                   it->face_id = save_face_id;
 23689                   it->ascent = save_ascent;
 23690                   it->descent = save_descent;
 23691                 }
 23692             }
 23693 
 23694           /* Fill space until window edge with the merged face.  Do that
 23695              only for L2R rows, as R2L rows are handled specially below.  */
 23696           if (!it->glyph_row->reversed_p)
 23697             {
 23698               const int stretch_width = it->last_visible_x - it->current_x;
 23699 
 23700               if (stretch_width > 0)
 23701                 {
 23702                   clear_position (it);
 23703                   append_stretch_glyph (it, Qnil, stretch_width,
 23704                                         stretch_height, stretch_ascent);
 23705                 }
 23706             }
 23707 
 23708           it->char_to_display = saved_char;
 23709           it->position = saved_pos;
 23710           it->avoid_cursor_p = saved_avoid_cursor;
 23711           it->start_of_box_run_p = saved_box_start;
 23712           it->object = save_object;
 23713           it->face_id = saved_face_id;
 23714         }
 23715       if (it->glyph_row->reversed_p)
 23716         {
 23717           /* Prepend a stretch glyph to the row, such that the
 23718              rightmost glyph will be drawn flushed all the way to the
 23719              right margin of the window.  The stretch glyph that will
 23720              occupy the empty space, if any, to the left of the
 23721              glyph.  */
 23722           struct font *font = face->font ? face->font : FRAME_FONT (f);
 23723           struct glyph *row_start = it->glyph_row->glyphs[TEXT_AREA];
 23724           struct glyph *row_end = row_start + it->glyph_row->used[TEXT_AREA];
 23725           struct glyph *g;
 23726           int row_width, stretch_ascent, stretch_width;
 23727           struct text_pos saved_pos;
 23728           int saved_face_id;
 23729           bool saved_avoid_cursor, saved_box_start;
 23730 
 23731           for (row_width = 0, g = row_start; g < row_end; g++)
 23732             row_width += g->pixel_width;
 23733 
 23734           /* FIXME: There are various minor display glitches in R2L
 23735              rows when only one of the fringes is missing.  The
 23736              strange condition below produces the least bad effect.  */
 23737           if ((WINDOW_LEFT_FRINGE_WIDTH (it->w) == 0)
 23738               == (WINDOW_RIGHT_FRINGE_WIDTH (it->w) == 0)
 23739               || WINDOW_RIGHT_FRINGE_WIDTH (it->w) != 0)
 23740             stretch_width = window_box_width (it->w, TEXT_AREA);
 23741           else
 23742             stretch_width = it->last_visible_x - it->first_visible_x;
 23743           stretch_width -= row_width;
 23744 
 23745           if (stretch_width > 0)
 23746             {
 23747               stretch_ascent =
 23748                 (((it->ascent + it->descent)
 23749                   * FONT_BASE (font)) / FONT_HEIGHT (font));
 23750               saved_pos = it->position;
 23751               clear_position (it);
 23752               saved_avoid_cursor = it->avoid_cursor_p;
 23753               it->avoid_cursor_p = true;
 23754               saved_face_id = it->face_id;
 23755               saved_box_start = it->start_of_box_run_p;
 23756               /* The last row's stretch glyph should get the default
 23757                  face, to avoid painting the rest of the window with
 23758                  the region face, if the region ends at ZV.  */
 23759               it->face_id = (it->glyph_row->ends_at_zv_p ?
 23760                              default_face->id : face->id);
 23761 
 23762               it->start_of_box_run_p = false;
 23763               append_stretch_glyph (it, Qnil, stretch_width,
 23764                                     it->ascent + it->descent, stretch_ascent);
 23765               it->position = saved_pos;
 23766               it->avoid_cursor_p = saved_avoid_cursor;
 23767               it->face_id = saved_face_id;
 23768               it->start_of_box_run_p = saved_box_start;
 23769             }
 23770           /* If stretch_width comes out negative, it means that the
 23771              last glyph is only partially visible.  In R2L rows, we
 23772              want the leftmost glyph to be partially visible, so we
 23773              need to give the row the corresponding left offset.  */
 23774           if (stretch_width < 0)
 23775             it->glyph_row->x = stretch_width;
 23776         }
 23777       it->face_id = orig_face_id;
 23778     }
 23779   else
 23780 #endif  /* HAVE_WINDOW_SYSTEM */
 23781     {
 23782       /* Save some values that must not be changed.  */
 23783       int saved_x = it->current_x;
 23784       struct text_pos saved_pos = it->position;
 23785       Lisp_Object saved_object = it->object;;
 23786       enum display_element_type saved_what = it->what;
 23787 
 23788       it->what = IT_CHARACTER;
 23789       clear_position (it);
 23790       it->object = Qnil;
 23791       it->c = it->char_to_display = ' ';
 23792       it->len = 1;
 23793 
 23794       if (WINDOW_LEFT_MARGIN_WIDTH (it->w) > 0
 23795           && (it->glyph_row->used[LEFT_MARGIN_AREA]
 23796               < WINDOW_LEFT_MARGIN_WIDTH (it->w))
 23797           && !it->glyph_row->mode_line_p
 23798           && face->background != FRAME_BACKGROUND_PIXEL (f))
 23799         {
 23800           struct glyph *g = it->glyph_row->glyphs[LEFT_MARGIN_AREA];
 23801           struct glyph *e = g + it->glyph_row->used[LEFT_MARGIN_AREA];
 23802 
 23803           for (it->current_x = 0; g < e; g++)
 23804             it->current_x += g->pixel_width;
 23805 
 23806           it->area = LEFT_MARGIN_AREA;
 23807           it->face_id = default_face->id;
 23808           while (it->glyph_row->used[LEFT_MARGIN_AREA]
 23809                  < WINDOW_LEFT_MARGIN_WIDTH (it->w)
 23810                  && g < it->glyph_row->glyphs[TEXT_AREA])
 23811             {
 23812               PRODUCE_GLYPHS (it);
 23813               /* term.c:produce_glyphs advances it->current_x only for
 23814                  TEXT_AREA.  */
 23815               it->current_x += it->pixel_width;
 23816               g++;
 23817             }
 23818 
 23819           it->current_x = saved_x;
 23820           it->area = TEXT_AREA;
 23821         }
 23822 
 23823       /* The last row's blank glyphs should get the default face, to
 23824          avoid painting the rest of the window with the region face,
 23825          if the region ends at ZV.  */
 23826       it->face_id = (it->glyph_row->ends_at_zv_p ?
 23827                      default_face->id : face->id);
 23828 
 23829       /* Make sure our idea of current_x is in sync with the glyphs
 23830          actually in the glyph row.  They might differ because
 23831          append_space_for_newline can insert one glyph without
 23832          updating current_x.  */
 23833       it->current_x = it->glyph_row->used[TEXT_AREA];
 23834 
 23835       /* The above assignment causes the code below to use a
 23836          non-standard semantics of it->current_x: it is measured
 23837          relative to the beginning of the text-area, thus disregarding
 23838          the window's hscroll.  That is why we need to correct the
 23839          indicator column for the hscroll, otherwise the indicator
 23840          will not move together with the text as result of horizontal
 23841          scrolling.  */
 23842       const int indicator_column =
 23843         fill_column_indicator_column (it, 1) - it->first_visible_x;
 23844 
 23845       /* Display fill-column indicator if needed.  */
 23846       while (it->current_x <= it->last_visible_x)
 23847         {
 23848           if (it->current_x != indicator_column)
 23849             PRODUCE_GLYPHS (it);
 23850           else
 23851             {
 23852               int saved_face_id = it->face_id;
 23853               it->face_id
 23854                 = merge_faces (it->w, Qfill_column_indicator, 0, extend_face_id);
 23855               it->c = it->char_to_display
 23856                 = XFIXNAT (Vdisplay_fill_column_indicator_character);
 23857 
 23858               PRODUCE_GLYPHS (it);
 23859 
 23860               it->face_id = saved_face_id;
 23861               it->c = it->char_to_display = ' ';
 23862             }
 23863         }
 23864 
 23865       if (WINDOW_RIGHT_MARGIN_WIDTH (it->w) > 0
 23866           && (it->glyph_row->used[RIGHT_MARGIN_AREA]
 23867               < WINDOW_RIGHT_MARGIN_WIDTH (it->w))
 23868           && !it->glyph_row->mode_line_p
 23869           && face->background != FRAME_BACKGROUND_PIXEL (f))
 23870         {
 23871           struct glyph *g = it->glyph_row->glyphs[RIGHT_MARGIN_AREA];
 23872           struct glyph *e = g + it->glyph_row->used[RIGHT_MARGIN_AREA];
 23873 
 23874           for ( ; g < e; g++)
 23875             it->current_x += g->pixel_width;
 23876 
 23877           it->area = RIGHT_MARGIN_AREA;
 23878           it->face_id = default_face->id;
 23879           while (it->glyph_row->used[RIGHT_MARGIN_AREA]
 23880                  < WINDOW_RIGHT_MARGIN_WIDTH (it->w)
 23881                  && g < it->glyph_row->glyphs[LAST_AREA])
 23882             {
 23883               PRODUCE_GLYPHS (it);
 23884               it->current_x += it->pixel_width;
 23885               g++;
 23886             }
 23887 
 23888           it->area = TEXT_AREA;
 23889         }
 23890 
 23891       /* Don't count these blanks really.  It would let us insert a left
 23892          truncation glyph below and make us set the cursor on them, maybe.  */
 23893       it->current_x = saved_x;
 23894       it->object = saved_object;
 23895       it->position = saved_pos;
 23896       it->what = saved_what;
 23897       it->face_id = orig_face_id;
 23898     }
 23899 }
 23900 
 23901 
 23902 /* Value is true if text starting at CHARPOS in current_buffer is
 23903    trailing whitespace.  */
 23904 
 23905 static bool
 23906 trailing_whitespace_p (ptrdiff_t charpos)
 23907 {
 23908   ptrdiff_t bytepos = CHAR_TO_BYTE (charpos);
 23909   int c = 0;
 23910 
 23911   while (bytepos < ZV_BYTE
 23912          && (c = FETCH_BYTE (bytepos),
 23913              c == ' ' || c == '\t'))
 23914     ++bytepos;
 23915 
 23916   if (bytepos >= ZV_BYTE || c == '\n' || c == '\r')
 23917     {
 23918       if (bytepos != PT_BYTE)
 23919         return true;
 23920     }
 23921   return false;
 23922 }
 23923 
 23924 
 23925 /* Highlight trailing whitespace, if any, in row at IT.  */
 23926 
 23927 static void
 23928 highlight_trailing_whitespace (struct it *it)
 23929 {
 23930   struct glyph_row *row = it->glyph_row;
 23931   int used = row->used[TEXT_AREA];
 23932 
 23933   if (used)
 23934     {
 23935       struct glyph *start = row->glyphs[TEXT_AREA];
 23936       struct glyph *glyph = start + used - 1;
 23937 
 23938       if (row->reversed_p)
 23939         {
 23940           /* Right-to-left rows need to be processed in the opposite
 23941              direction, so swap the edge pointers. */
 23942           glyph = start;
 23943           start = row->glyphs[TEXT_AREA] + used - 1;
 23944         }
 23945 
 23946       /* Skip over glyphs inserted to display the cursor at the
 23947          end of a line, for extending the face of the last glyph
 23948          to the end of the line on terminals, and for truncation
 23949          and continuation glyphs.  */
 23950       if (!row->reversed_p)
 23951         {
 23952           while (glyph >= start
 23953                  && (glyph->type == CHAR_GLYPH
 23954                      || glyph->type == STRETCH_GLYPH)
 23955                  && NILP (glyph->object))
 23956             --glyph;
 23957         }
 23958       else
 23959         {
 23960           while (glyph <= start
 23961                  && (glyph->type == CHAR_GLYPH || glyph->type == STRETCH_GLYPH)
 23962                  && NILP (glyph->object))
 23963             ++glyph;
 23964         }
 23965 
 23966       /* If last glyph is a space or stretch, and it's trailing
 23967          whitespace, set the face of all trailing whitespace glyphs in
 23968          IT->glyph_row to `trailing-whitespace'.  */
 23969       if ((row->reversed_p ? glyph <= start : glyph >= start)
 23970           && BUFFERP (glyph->object)
 23971           && (glyph->type == STRETCH_GLYPH
 23972               || (glyph->type == CHAR_GLYPH
 23973                   && glyph->u.ch == ' '))
 23974           && trailing_whitespace_p (glyph->charpos))
 23975         {
 23976           int face_id = lookup_named_face (it->w, it->f, Qtrailing_whitespace, false);
 23977           if (face_id < 0)
 23978             return;
 23979 
 23980           if (!row->reversed_p)
 23981             {
 23982               while (glyph >= start
 23983                      && BUFFERP (glyph->object)
 23984                      && (glyph->type == STRETCH_GLYPH
 23985                          || (glyph->type == CHAR_GLYPH
 23986                              && glyph->u.ch == ' ')))
 23987                 (glyph--)->face_id = face_id;
 23988             }
 23989           else
 23990             {
 23991               while (glyph <= start
 23992                      && BUFFERP (glyph->object)
 23993                      && (glyph->type == STRETCH_GLYPH
 23994                          || (glyph->type == CHAR_GLYPH
 23995                              && glyph->u.ch == ' ')))
 23996                 (glyph++)->face_id = face_id;
 23997             }
 23998         }
 23999     }
 24000 }
 24001 
 24002 
 24003 /* Value is true if glyph row ROW should be
 24004    considered to hold the buffer position CHARPOS.  */
 24005 
 24006 static bool
 24007 row_for_charpos_p (struct glyph_row *row, ptrdiff_t charpos)
 24008 {
 24009   bool result = true;
 24010 
 24011   if (charpos == CHARPOS (row->end.pos)
 24012       || charpos == MATRIX_ROW_END_CHARPOS (row))
 24013     {
 24014       /* Suppose the row ends on a string.
 24015          Unless the row is continued, that means it ends on a newline
 24016          in the string.  If it's anything other than a display string
 24017          (e.g., a before-string from an overlay), we don't want the
 24018          cursor there.  (This heuristic seems to give the optimal
 24019          behavior for the various types of multi-line strings.)
 24020          One exception: if the string has `cursor' property on one of
 24021          its characters, we _do_ want the cursor there.  */
 24022       if (CHARPOS (row->end.string_pos) >= 0)
 24023         {
 24024           if (row->continued_p)
 24025             result = true;
 24026           else
 24027             {
 24028               /* Check for `display' property.  */
 24029               struct glyph *beg = row->glyphs[TEXT_AREA];
 24030               struct glyph *end = beg + row->used[TEXT_AREA] - 1;
 24031               struct glyph *glyph;
 24032 
 24033               result = false;
 24034               for (glyph = end; glyph >= beg; --glyph)
 24035                 if (STRINGP (glyph->object))
 24036                   {
 24037                     Lisp_Object prop
 24038                       = Fget_char_property (make_fixnum (charpos),
 24039                                             Qdisplay, Qnil);
 24040                     result =
 24041                       (!NILP (prop)
 24042                        && display_prop_string_p (prop, glyph->object));
 24043                     /* If there's a `cursor' property on one of the
 24044                        string's characters, this row is a cursor row,
 24045                        even though this is not a display string.  */
 24046                     if (!result)
 24047                       {
 24048                         Lisp_Object s = glyph->object;
 24049 
 24050                         for ( ; glyph >= beg && EQ (glyph->object, s); --glyph)
 24051                           {
 24052                             ptrdiff_t gpos = glyph->charpos;
 24053 
 24054                             if (!NILP (Fget_char_property (make_fixnum (gpos),
 24055                                                            Qcursor, s)))
 24056                               {
 24057                                 result = true;
 24058                                 break;
 24059                               }
 24060                           }
 24061                       }
 24062                     break;
 24063                   }
 24064             }
 24065         }
 24066       else if (MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (row))
 24067         {
 24068           /* If the row ends in middle of a real character,
 24069              and the line is continued, we want the cursor here.
 24070              That's because CHARPOS (ROW->end.pos) would equal
 24071              PT if PT is before the character.  */
 24072           if (!row->ends_in_ellipsis_p)
 24073             result = row->continued_p;
 24074           else
 24075           /* If the row ends in an ellipsis, then
 24076              CHARPOS (ROW->end.pos) will equal point after the
 24077              invisible text.  We want that position to be displayed
 24078              after the ellipsis.  */
 24079             result = false;
 24080         }
 24081       /* If the row ends at ZV, display the cursor at the end of that
 24082          row instead of at the start of the row below.  */
 24083       else
 24084         result = row->ends_at_zv_p;
 24085     }
 24086 
 24087   return result;
 24088 }
 24089 
 24090 /* Value is true if glyph row ROW should be
 24091    used to hold the cursor.  */
 24092 
 24093 static bool
 24094 cursor_row_p (struct glyph_row *row)
 24095 {
 24096   return row_for_charpos_p (row, PT);
 24097 }
 24098 
 24099 
 24100 
 24101 /* Push the property PROP so that it will be rendered at the current
 24102    position in IT.  Return true if PROP was successfully pushed, false
 24103    otherwise.  Called from handle_line_prefix to handle the
 24104    `line-prefix' and `wrap-prefix' properties.  */
 24105 
 24106 static bool
 24107 push_prefix_prop (struct it *it, Lisp_Object prop)
 24108 {
 24109   struct text_pos pos =
 24110     STRINGP (it->string) ? it->current.string_pos : it->current.pos;
 24111 
 24112   eassert (it->method == GET_FROM_BUFFER
 24113            || it->method == GET_FROM_DISPLAY_VECTOR
 24114            || it->method == GET_FROM_STRING
 24115            || it->method == GET_FROM_IMAGE);
 24116 
 24117   /* We need to save the current buffer/string position, so it will be
 24118      restored by pop_it, because iterate_out_of_display_property
 24119      depends on that being set correctly, but some situations leave
 24120      it->position not yet set when this function is called.  */
 24121   push_it (it, &pos);
 24122 
 24123   if (STRINGP (prop))
 24124     {
 24125       if (SCHARS (prop) == 0)
 24126         {
 24127           pop_it (it);
 24128           return false;
 24129         }
 24130 
 24131       it->string = prop;
 24132       it->string_from_prefix_prop_p = true;
 24133       it->multibyte_p = STRING_MULTIBYTE (it->string);
 24134       it->current.overlay_string_index = -1;
 24135       IT_STRING_CHARPOS (*it) = IT_STRING_BYTEPOS (*it) = 0;
 24136       it->end_charpos = it->string_nchars = SCHARS (it->string);
 24137       it->method = GET_FROM_STRING;
 24138       it->stop_charpos = 0;
 24139       it->prev_stop = 0;
 24140       it->base_level_stop = 0;
 24141       it->cmp_it.id = -1;
 24142 
 24143       /* Force paragraph direction to be that of the parent
 24144          buffer/string.  */
 24145       if (it->bidi_p && it->bidi_it.paragraph_dir == R2L)
 24146         it->paragraph_embedding = it->bidi_it.paragraph_dir;
 24147       else
 24148         it->paragraph_embedding = L2R;
 24149 
 24150       /* Set up the bidi iterator for this display string.  */
 24151       if (it->bidi_p)
 24152         {
 24153           it->bidi_it.string.lstring = it->string;
 24154           it->bidi_it.string.s = NULL;
 24155           it->bidi_it.string.schars = it->end_charpos;
 24156           it->bidi_it.string.bufpos = IT_CHARPOS (*it);
 24157           it->bidi_it.string.from_disp_str = it->string_from_display_prop_p;
 24158           it->bidi_it.string.unibyte = !it->multibyte_p;
 24159           it->bidi_it.w = it->w;
 24160           bidi_init_it (0, 0, FRAME_WINDOW_P (it->f), &it->bidi_it);
 24161         }
 24162     }
 24163   else if (CONSP (prop) && EQ (XCAR (prop), Qspace))
 24164     {
 24165       it->method = GET_FROM_STRETCH;
 24166       it->object = prop;
 24167     }
 24168 #ifdef HAVE_WINDOW_SYSTEM
 24169   else if (IMAGEP (prop))
 24170     {
 24171       it->what = IT_IMAGE;
 24172       it->image_id = lookup_image (it->f, prop, it->face_id);
 24173       it->method = GET_FROM_IMAGE;
 24174     }
 24175 #endif /* HAVE_WINDOW_SYSTEM */
 24176   else
 24177     {
 24178       pop_it (it);              /* bogus display property, give up */
 24179       return false;
 24180     }
 24181 
 24182   return true;
 24183 }
 24184 
 24185 /* Return the character-property PROP at the current position in IT.  */
 24186 
 24187 static Lisp_Object
 24188 get_it_property (struct it *it, Lisp_Object prop)
 24189 {
 24190   Lisp_Object position, object = it->object;
 24191 
 24192   if (STRINGP (object))
 24193     position = make_fixnum (IT_STRING_CHARPOS (*it));
 24194   else if (BUFFERP (object))
 24195     {
 24196       position = make_fixnum (IT_CHARPOS (*it));
 24197       object = it->window;
 24198     }
 24199   else
 24200     return Qnil;
 24201 
 24202   return Fget_char_property (position, prop, object);
 24203 }
 24204 
 24205 /* Return the line-prefix/wrap-prefix property, checking both the
 24206    current IT->OBJECT and the underlying buffer text.  */
 24207 
 24208 static Lisp_Object
 24209 get_line_prefix_it_property (struct it *it, Lisp_Object prop)
 24210 {
 24211   Lisp_Object prefix = get_it_property (it, prop);
 24212 
 24213   /* If we are looking at a display or overlay string, check also the
 24214      underlying buffer text.  */
 24215   if (NILP (prefix) && it->sp > 0 && STRINGP (it->object))
 24216     return Fget_char_property (make_fixnum (IT_CHARPOS (*it)), prop,
 24217                                it->w->contents);
 24218   return prefix;
 24219 }
 24220 
 24221 /* See if there's a line- or wrap-prefix, and if so, push it on IT.  */
 24222 
 24223 static void
 24224 handle_line_prefix (struct it *it)
 24225 {
 24226   Lisp_Object prefix;
 24227 
 24228   if (it->continuation_lines_width > 0)
 24229     {
 24230       prefix = get_line_prefix_it_property (it, Qwrap_prefix);
 24231       if (NILP (prefix))
 24232         prefix = Vwrap_prefix;
 24233     }
 24234   else
 24235     {
 24236       prefix = get_line_prefix_it_property (it, Qline_prefix);
 24237       if (NILP (prefix))
 24238         prefix = Vline_prefix;
 24239     }
 24240   if (! NILP (prefix) && push_prefix_prop (it, prefix))
 24241     {
 24242       /* If the prefix is wider than the window, and we try to wrap
 24243          it, it would acquire its own wrap prefix, and so on till the
 24244          iterator stack overflows.  So, don't wrap the prefix.  */
 24245       it->line_wrap = TRUNCATE;
 24246       it->avoid_cursor_p = true;
 24247     }
 24248 }
 24249 
 24250 
 24251 
 24252 /* Remove N glyphs at the start of a reversed IT->glyph_row.  Called
 24253    only for R2L lines from display_line and display_string, when they
 24254    decide that too many glyphs were produced by PRODUCE_GLYPHS, and
 24255    the line/string needs to be continued on the next glyph row.  */
 24256 static void
 24257 unproduce_glyphs (struct it *it, int n)
 24258 {
 24259   struct glyph *glyph, *end;
 24260 
 24261   eassert (it->glyph_row);
 24262   eassert (it->glyph_row->reversed_p);
 24263   eassert (it->area == TEXT_AREA);
 24264   eassert (n <= it->glyph_row->used[TEXT_AREA]);
 24265 
 24266   if (n > it->glyph_row->used[TEXT_AREA])
 24267     n = it->glyph_row->used[TEXT_AREA];
 24268   glyph = it->glyph_row->glyphs[TEXT_AREA] + n;
 24269   end = it->glyph_row->glyphs[TEXT_AREA] + it->glyph_row->used[TEXT_AREA];
 24270   for ( ; glyph < end; glyph++)
 24271     glyph[-n] = *glyph;
 24272 }
 24273 
 24274 /* Find the positions in a bidi-reordered ROW to serve as ROW->minpos
 24275    and ROW->maxpos.  */
 24276 static void
 24277 find_row_edges (struct it *it, struct glyph_row *row,
 24278                 ptrdiff_t min_pos, ptrdiff_t min_bpos,
 24279                 ptrdiff_t max_pos, ptrdiff_t max_bpos)
 24280 {
 24281   /* FIXME: Revisit this when glyph ``spilling'' in continuation
 24282      lines' rows is implemented for bidi-reordered rows.  */
 24283 
 24284   /* ROW->minpos is the value of min_pos, the minimal buffer position
 24285      we have in ROW, or ROW->start.pos if that is smaller.  */
 24286   if (min_pos <= ZV && min_pos < row->start.pos.charpos)
 24287     SET_TEXT_POS (row->minpos, min_pos, min_bpos);
 24288   else
 24289     /* We didn't find buffer positions smaller than ROW->start, or
 24290        didn't find _any_ valid buffer positions in any of the glyphs,
 24291        so we must trust the iterator's computed positions.  */
 24292       row->minpos = row->start.pos;
 24293   if (max_pos <= 0)
 24294     {
 24295       max_pos = CHARPOS (it->current.pos);
 24296       max_bpos = BYTEPOS (it->current.pos);
 24297     }
 24298 
 24299   /* Here are the various use-cases for ending the row, and the
 24300      corresponding values for ROW->maxpos:
 24301 
 24302      Line ends in a newline from buffer       eol_pos + 1
 24303      Line is continued from buffer            max_pos + 1
 24304      Line is truncated on right               it->current.pos
 24305      Line ends in a newline from string       max_pos + 1(*)
 24306       (*) + 1 only when line ends in a forward scan
 24307      Line is continued from string            max_pos
 24308      Line is continued from display vector    max_pos
 24309      Line is entirely from a string           min_pos == max_pos
 24310      Line is entirely from a display vector   min_pos == max_pos
 24311      Line that ends at ZV                     ZV
 24312 
 24313      If you discover other use-cases, please add them here as
 24314      appropriate.  */
 24315   if (row->ends_at_zv_p)
 24316     row->maxpos = it->current.pos;
 24317   else if (row->used[TEXT_AREA])
 24318     {
 24319       bool seen_this_string = false;
 24320       struct glyph_row *r1 = row - 1;
 24321 
 24322       /* Did we see the same display string on the previous row?  */
 24323       if (STRINGP (it->object)
 24324           /* this is not the first row */
 24325           && row > it->w->desired_matrix->rows
 24326           /* previous row is not the header line or tab-line */
 24327           && !r1->mode_line_p
 24328           /* previous row also ends in a newline from a string */
 24329           && r1->ends_in_newline_from_string_p)
 24330         {
 24331           struct glyph *start, *end;
 24332 
 24333           /* Search for the last glyph of the previous row that came
 24334              from buffer or string.  Depending on whether the row is
 24335              L2R or R2L, we need to process it front to back or the
 24336              other way round.  */
 24337           if (!r1->reversed_p)
 24338             {
 24339               start = r1->glyphs[TEXT_AREA];
 24340               end = start + r1->used[TEXT_AREA];
 24341               /* Glyphs inserted by redisplay have nil as their object.  */
 24342               while (end > start
 24343                      && NILP ((end - 1)->object)
 24344                      && (end - 1)->charpos <= 0)
 24345                 --end;
 24346               if (end > start)
 24347                 {
 24348                   if (EQ ((end - 1)->object, it->object))
 24349                     seen_this_string = true;
 24350                 }
 24351               else
 24352                 /* If all the glyphs of the previous row were inserted
 24353                    by redisplay, it means the previous row was
 24354                    produced from a single newline, which is only
 24355                    possible if that newline came from the same string
 24356                    as the one which produced this ROW.  */
 24357                 seen_this_string = true;
 24358             }
 24359           else
 24360             {
 24361               end = r1->glyphs[TEXT_AREA] - 1;
 24362               start = end + r1->used[TEXT_AREA];
 24363               while (end < start
 24364                      && NILP ((end + 1)->object)
 24365                      && (end + 1)->charpos <= 0)
 24366                 ++end;
 24367               if (end < start)
 24368                 {
 24369                   if (EQ ((end + 1)->object, it->object))
 24370                     seen_this_string = true;
 24371                 }
 24372               else
 24373                 seen_this_string = true;
 24374             }
 24375         }
 24376       /* Take note of each display string that covers a newline only
 24377          once, the first time we see it.  This is for when a display
 24378          string includes more than one newline in it.  */
 24379       if (row->ends_in_newline_from_string_p && !seen_this_string)
 24380         {
 24381           /* If we were scanning the buffer forward when we displayed
 24382              the string, we want to account for at least one buffer
 24383              position that belongs to this row (position covered by
 24384              the display string), so that cursor positioning will
 24385              consider this row as a candidate when point is at the end
 24386              of the visual line represented by this row.  This is not
 24387              required when scanning back, because max_pos will already
 24388              have a much larger value.  */
 24389           if (CHARPOS (row->end.pos) > max_pos)
 24390             inc_both (&max_pos, &max_bpos);
 24391           SET_TEXT_POS (row->maxpos, max_pos, max_bpos);
 24392         }
 24393       else if (CHARPOS (it->eol_pos) > 0)
 24394         SET_TEXT_POS (row->maxpos,
 24395                       CHARPOS (it->eol_pos) + 1, BYTEPOS (it->eol_pos) + 1);
 24396       else if (row->continued_p)
 24397         {
 24398           /* If max_pos is different from IT's current position, it
 24399              means IT->method does not belong to the display element
 24400              at max_pos.  However, it also means that the display
 24401              element at max_pos was displayed in its entirety on this
 24402              line, which is equivalent to saying that the next line
 24403              starts at the next buffer position.  */
 24404           if (IT_CHARPOS (*it) == max_pos && it->method != GET_FROM_BUFFER)
 24405             SET_TEXT_POS (row->maxpos, max_pos, max_bpos);
 24406           else
 24407             {
 24408               inc_both (&max_pos, &max_bpos);
 24409               SET_TEXT_POS (row->maxpos, max_pos, max_bpos);
 24410             }
 24411         }
 24412       else if (row->truncated_on_right_p)
 24413         /* display_line already called reseat_at_next_visible_line_start,
 24414            which puts the iterator at the beginning of the next line, in
 24415            the logical order. */
 24416         row->maxpos = it->current.pos;
 24417       else if (max_pos == min_pos && it->method != GET_FROM_BUFFER)
 24418         /* A line that is entirely from a string/image/stretch...  */
 24419         row->maxpos = row->minpos;
 24420       else
 24421         emacs_abort ();
 24422     }
 24423   else
 24424     row->maxpos = it->current.pos;
 24425 }
 24426 
 24427 /* Like display_count_lines, but capable of counting outside of the
 24428    current narrowed region.  */
 24429 static ptrdiff_t
 24430 display_count_lines_logically (ptrdiff_t start_byte, ptrdiff_t limit_byte,
 24431                                ptrdiff_t count, ptrdiff_t *byte_pos_ptr)
 24432 {
 24433   if (!display_line_numbers_widen || (BEGV == BEG && ZV == Z))
 24434     return display_count_lines (start_byte, limit_byte, count, byte_pos_ptr);
 24435 
 24436   ptrdiff_t val;
 24437   specpdl_ref pdl_count = SPECPDL_INDEX ();
 24438   record_unwind_protect (save_restriction_restore, save_restriction_save ());
 24439   labeled_restrictions_remove_in_current_buffer ();
 24440   Fwiden ();
 24441   val = display_count_lines (start_byte, limit_byte, count, byte_pos_ptr);
 24442   unbind_to (pdl_count, Qnil);
 24443   return val;
 24444 }
 24445 
 24446 /* Count the number of screen lines in window IT->w between character
 24447    position IT_CHARPOS(*IT) and the line showing that window's point.  */
 24448 static ptrdiff_t
 24449 display_count_lines_visually (struct it *it)
 24450 {
 24451   struct it tem_it;
 24452   ptrdiff_t to;
 24453   struct text_pos from;
 24454 
 24455   /* If we already calculated a relative line number, use that.  This
 24456      trick relies on the fact that visual lines (a.k.a. "glyph rows")
 24457      are laid out sequentially, one by one, for each sequence of calls
 24458      to display_line or other similar function that follows a call to
 24459      init_iterator.  */
 24460   if (it->lnum_bytepos > 0)
 24461     return it->lnum + 1;
 24462   else
 24463     {
 24464       specpdl_ref count = SPECPDL_INDEX ();
 24465 
 24466       if (IT_CHARPOS (*it) <= PT)
 24467         {
 24468           from = it->current.pos;
 24469           to = PT;
 24470         }
 24471       else
 24472         {
 24473           SET_TEXT_POS (from, PT, PT_BYTE);
 24474           to = IT_CHARPOS (*it);
 24475         }
 24476       /* Need to disable visual mode temporarily, since otherwise the
 24477          call to move_it_to below and inside start_display will cause
 24478          infinite recursion.  */
 24479       specbind (Qdisplay_line_numbers, Qrelative);
 24480       start_display (&tem_it, it->w, from);
 24481       /* Some redisplay optimizations could invoke us very far from
 24482          PT, which will make the caller painfully slow.  There should
 24483          be no need to go too far beyond the window's bottom, as any
 24484          such optimization will fail to show point anyway.  */
 24485       move_it_to (&tem_it, to, -1,
 24486                   tem_it.last_visible_y
 24487                   + (SCROLL_LIMIT + 10) * FRAME_LINE_HEIGHT (tem_it.f),
 24488                   -1, MOVE_TO_POS | MOVE_TO_Y);
 24489       unbind_to (count, Qnil);
 24490       return IT_CHARPOS (*it) <= PT ? -tem_it.vpos : tem_it.vpos;
 24491     }
 24492 }
 24493 
 24494 /* Produce the line-number glyphs for the current glyph_row.  If
 24495    IT->glyph_row is non-NULL, populate the row with the produced
 24496    glyphs.  */
 24497 static void
 24498 maybe_produce_line_number (struct it *it)
 24499 {
 24500   ptrdiff_t last_line = it->lnum;
 24501   ptrdiff_t start_from, bytepos;
 24502   ptrdiff_t this_line;
 24503   bool first_time = false;
 24504   ptrdiff_t beg_byte;
 24505   ptrdiff_t z_byte;
 24506   bool line_numbers_wide;
 24507   void *itdata = bidi_shelve_cache ();
 24508 
 24509   if (display_line_numbers_offset
 24510       && !display_line_numbers_widen
 24511       && !EQ (Vdisplay_line_numbers, Qvisual)
 24512       && !EQ (Vdisplay_line_numbers, Qrelative))
 24513     line_numbers_wide = true;
 24514   else
 24515     line_numbers_wide = display_line_numbers_widen;
 24516 
 24517   beg_byte = line_numbers_wide ? BEG_BYTE : BEGV_BYTE;
 24518   z_byte = line_numbers_wide ? Z_BYTE : ZV_BYTE;
 24519 
 24520   if (EQ (Vdisplay_line_numbers, Qvisual))
 24521     this_line = display_count_lines_visually (it);
 24522   else
 24523     {
 24524       if (!last_line)
 24525         {
 24526           /* If possible, reuse data cached by line-number-mode.  */
 24527           if (it->w->base_line_number > 0
 24528               && it->w->base_line_pos > 0
 24529               && it->w->base_line_pos <= IT_CHARPOS (*it)
 24530               /* line-number-mode always displays narrowed line
 24531                  numbers, so we cannot use its data if the user wants
 24532                  line numbers that disregard narrowing, or if the
 24533                  buffer's narrowing has just changed.  */
 24534               && !(line_numbers_wide
 24535                    && (BEG_BYTE != BEGV_BYTE || Z_BYTE != ZV_BYTE))
 24536               && !current_buffer->clip_changed)
 24537             {
 24538               start_from = CHAR_TO_BYTE (it->w->base_line_pos);
 24539               last_line = it->w->base_line_number - 1;
 24540             }
 24541           else
 24542             start_from = beg_byte;
 24543           if (!it->lnum_bytepos)
 24544             first_time = true;
 24545         }
 24546       else
 24547         start_from = it->lnum_bytepos;
 24548 
 24549       /* Paranoia: what if someone changes the narrowing since the
 24550          last time display_line was called?  Shouldn't really happen,
 24551          but who knows what some crazy Lisp invoked by :eval could do?  */
 24552       if (!(beg_byte <= start_from && start_from <= z_byte))
 24553         {
 24554           last_line = 0;
 24555           start_from = beg_byte;
 24556         }
 24557 
 24558       this_line =
 24559         last_line + display_count_lines_logically (start_from,
 24560                                                    IT_BYTEPOS (*it),
 24561                                                    IT_CHARPOS (*it), &bytepos);
 24562       eassert (this_line > 0 || (this_line == 0 && start_from == beg_byte));
 24563       eassert (bytepos == IT_BYTEPOS (*it));
 24564     }
 24565 
 24566   /* Record the line number information.  */
 24567   if (this_line != last_line || !it->lnum_bytepos)
 24568     {
 24569       it->lnum = this_line;
 24570       it->lnum_bytepos = IT_BYTEPOS (*it);
 24571     }
 24572 
 24573   /* Produce the glyphs for the line number.  */
 24574   struct it tem_it;
 24575   char lnum_buf[INT_STRLEN_BOUND (ptrdiff_t) + 1];
 24576   bool beyond_zv = IT_BYTEPOS (*it) >= ZV_BYTE ? true : false;
 24577   ptrdiff_t lnum_offset = -1; /* to produce 1-based line numbers */
 24578   int lnum_face_id = merge_faces (it->w, Qline_number, 0, DEFAULT_FACE_ID);
 24579   int current_lnum_face_id
 24580     = merge_faces (it->w, Qline_number_current_line, 0, DEFAULT_FACE_ID);
 24581   /* From here onwards, we must prevent freeing realized faces, because
 24582      we are using the above 2 face IDs for the glyphs we produce.  */
 24583   bool save_free_realized_faces = inhibit_free_realized_faces;
 24584   inhibit_free_realized_faces = true;
 24585   /* Compute point's line number if needed.  */
 24586   if ((EQ (Vdisplay_line_numbers, Qrelative)
 24587        || EQ (Vdisplay_line_numbers, Qvisual)
 24588        || lnum_face_id != current_lnum_face_id)
 24589       && !it->pt_lnum)
 24590     {
 24591       ptrdiff_t ignored;
 24592       if (PT_BYTE > it->lnum_bytepos && !EQ (Vdisplay_line_numbers, Qvisual))
 24593         it->pt_lnum =
 24594           this_line + display_count_lines_logically (it->lnum_bytepos, PT_BYTE,
 24595                                                      PT, &ignored);
 24596       else
 24597         it->pt_lnum = display_count_lines_logically (beg_byte, PT_BYTE, PT,
 24598                                                      &ignored);
 24599     }
 24600   /* Compute the required width if needed.  */
 24601   if (!it->lnum_width)
 24602     {
 24603       if (FIXNATP (Vdisplay_line_numbers_width))
 24604         it->lnum_width = XFIXNAT (Vdisplay_line_numbers_width);
 24605 
 24606       /* Max line number to be displayed cannot be more than the one
 24607          corresponding to the last row of the desired matrix.  */
 24608       ptrdiff_t max_lnum;
 24609 
 24610       if (NILP (Vdisplay_line_numbers_current_absolute)
 24611           && (EQ (Vdisplay_line_numbers, Qrelative)
 24612               || EQ (Vdisplay_line_numbers, Qvisual)))
 24613         /* We subtract one more because the current line is always
 24614            zero in this mode.  */
 24615         max_lnum = it->w->desired_matrix->nrows - 2;
 24616       else if (EQ (Vdisplay_line_numbers, Qvisual))
 24617         max_lnum = it->pt_lnum + it->w->desired_matrix->nrows - 1;
 24618       else
 24619         max_lnum = this_line + it->w->desired_matrix->nrows - 1 - it->vpos;
 24620       max_lnum = max (1, max_lnum);
 24621       it->lnum_width = max (it->lnum_width, log10 (max_lnum) + 1);
 24622       eassert (it->lnum_width > 0);
 24623     }
 24624   if (EQ (Vdisplay_line_numbers, Qrelative))
 24625     lnum_offset = it->pt_lnum;
 24626   else if (EQ (Vdisplay_line_numbers, Qvisual))
 24627     lnum_offset = 0;
 24628   else if (display_line_numbers_offset)
 24629     lnum_offset -= display_line_numbers_offset;
 24630 
 24631   /* Under 'relative', display the absolute line number for the
 24632      current line, unless the user requests otherwise.  */
 24633   ptrdiff_t lnum_to_display = eabs (this_line - lnum_offset);
 24634   if ((EQ (Vdisplay_line_numbers, Qrelative)
 24635        || EQ (Vdisplay_line_numbers, Qvisual))
 24636       && lnum_to_display == 0
 24637       && !NILP (Vdisplay_line_numbers_current_absolute))
 24638     lnum_to_display = it->pt_lnum + 1;
 24639   /* In L2R rows we need to append the blank separator, in R2L
 24640      rows we need to prepend it.  But this function is usually
 24641      called when no display elements were produced from the
 24642      following line, so the paragraph direction might be unknown.
 24643      Therefore we cheat and add 2 blanks, one on either side.  */
 24644   pint2str (lnum_buf, it->lnum_width + 1, lnum_to_display);
 24645   strcat (lnum_buf, " ");
 24646 
 24647   /* Setup for producing the glyphs.  */
 24648   init_iterator (&tem_it, it->w, -1, -1, &scratch_glyph_row,
 24649                  /* FIXME: Use specialized face.  */
 24650                  DEFAULT_FACE_ID);
 24651   scratch_glyph_row.reversed_p = false;
 24652   scratch_glyph_row.used[TEXT_AREA] = 0;
 24653   SET_TEXT_POS (tem_it.position, 0, 0);
 24654   tem_it.avoid_cursor_p = true;
 24655   tem_it.bidi_p = true;
 24656   tem_it.bidi_it.type = WEAK_EN;
 24657   /* According to UAX#9, EN goes up 2 levels in L2R paragraph and
 24658      1 level in R2L paragraphs.  Emulate that, assuming we are in
 24659      an L2R paragraph.  */
 24660   tem_it.bidi_it.resolved_level = 2;
 24661 
 24662   /* We must leave space for 2 glyphs for continuation and truncation,
 24663      and at least one glyph for buffer text.  */
 24664   int width_limit =
 24665     tem_it.last_visible_x - tem_it.first_visible_x
 24666     - 3 * FRAME_COLUMN_WIDTH (it->f);
 24667 
 24668   tem_it.face_id = lnum_face_id;
 24669   /* Avoid displaying any face other than line-number on
 24670      empty lines beyond EOB.  */
 24671   if (lnum_face_id != current_lnum_face_id
 24672       && (EQ (Vdisplay_line_numbers, Qvisual)
 24673           ? this_line == 0
 24674           : this_line == it->pt_lnum)
 24675       && it->what != IT_EOB)
 24676     tem_it.face_id = current_lnum_face_id;
 24677   else if (!beyond_zv)
 24678     {
 24679       if (display_line_numbers_major_tick > 0
 24680           && (lnum_to_display % display_line_numbers_major_tick == 0))
 24681         tem_it.face_id = merge_faces (it->w, Qline_number_major_tick,
 24682                                       0, DEFAULT_FACE_ID);
 24683       else if (display_line_numbers_minor_tick > 0
 24684                && (lnum_to_display % display_line_numbers_minor_tick == 0))
 24685         tem_it.face_id = merge_faces (it->w, Qline_number_minor_tick,
 24686                                       0, DEFAULT_FACE_ID);
 24687     }
 24688 
 24689   /* Produce glyphs for the line number in a scratch glyph_row.  */
 24690   for (const char *p = lnum_buf; *p; p++)
 24691     {
 24692       /* For continuation lines and lines after ZV, instead of a line
 24693          number, produce a blank prefix of the same width.  */
 24694       if (beyond_zv
 24695           /* Don't display the same line number more than once.  */
 24696           || (!EQ (Vdisplay_line_numbers, Qvisual)
 24697               && (it->continuation_lines_width > 0
 24698                   || (this_line == last_line && !first_time))))
 24699         tem_it.c = tem_it.char_to_display = ' ';
 24700       else
 24701         tem_it.c = tem_it.char_to_display = *p;
 24702       tem_it.len = 1;
 24703       /* Make sure these glyphs will have a "position" of -1.  */
 24704       SET_TEXT_POS (tem_it.position, -1, -1);
 24705       PRODUCE_GLYPHS (&tem_it);
 24706 
 24707       /* Stop producing glyphs, and refrain from producing the line
 24708          number, if we don't have enough space on this line.  */
 24709       if (tem_it.current_x >= width_limit)
 24710         {
 24711           it->lnum_width = 0;
 24712           it->lnum_pixel_width = 0;
 24713           bidi_unshelve_cache (itdata, false);
 24714           inhibit_free_realized_faces = save_free_realized_faces;
 24715           return;
 24716         }
 24717     }
 24718 
 24719   inhibit_free_realized_faces = save_free_realized_faces;
 24720 
 24721   /* Record the width in pixels we need for the line number display.  */
 24722   it->lnum_pixel_width = tem_it.current_x;
 24723   /* Copy the produced glyphs into IT's glyph_row.  */
 24724   struct glyph *g = scratch_glyph_row.glyphs[TEXT_AREA];
 24725   struct glyph *e = g + scratch_glyph_row.used[TEXT_AREA];
 24726   struct glyph *p = it->glyph_row ? it->glyph_row->glyphs[TEXT_AREA] : NULL;
 24727   short *u = it->glyph_row ? &it->glyph_row->used[TEXT_AREA] : NULL;
 24728 
 24729   eassert (it->glyph_row == NULL || it->glyph_row->used[TEXT_AREA] == 0);
 24730 
 24731   for ( ; g < e; g++)
 24732     {
 24733       it->current_x += g->pixel_width;
 24734       /* The following is important when this function is called
 24735          from move_it_in_display_line_to: HPOS is incremented only
 24736          when we are in the visible portion of the glyph row.  */
 24737       if (it->current_x > it->first_visible_x)
 24738         it->hpos++;
 24739       if (p)
 24740         {
 24741           *p++ = *g;
 24742           (*u)++;
 24743         }
 24744     }
 24745 
 24746   /* Update IT's metrics due to glyphs produced for line numbers.
 24747      Don't do that for rows beyond ZV, to avoid displaying a cursor of
 24748      different dimensions there.  */
 24749   if (!beyond_zv)
 24750     {
 24751       if (it->glyph_row)
 24752         {
 24753           struct glyph_row *row = it->glyph_row;
 24754 
 24755           it->max_ascent = max (row->ascent, tem_it.max_ascent);
 24756           it->max_descent = max (row->height - row->ascent, tem_it.max_descent);
 24757           it->max_phys_ascent = max (row->phys_ascent, tem_it.max_phys_ascent);
 24758           it->max_phys_descent = max (row->phys_height - row->phys_ascent,
 24759                                       tem_it.max_phys_descent);
 24760         }
 24761       else
 24762         {
 24763           it->max_ascent = max (it->max_ascent, tem_it.max_ascent);
 24764           it->max_descent = max (it->max_descent, tem_it.max_descent);
 24765           it->max_phys_ascent = max (it->max_phys_ascent,
 24766                                      tem_it.max_phys_ascent);
 24767           it->max_phys_descent = max (it->max_phys_descent,
 24768                                       tem_it.max_phys_descent);
 24769         }
 24770     }
 24771 
 24772   it->line_number_produced_p = true;
 24773 
 24774   bidi_unshelve_cache (itdata, false);
 24775 }
 24776 
 24777 /* Return true if this glyph row needs a line number to be produced
 24778    for it.  */
 24779 static bool
 24780 should_produce_line_number (struct it *it)
 24781 {
 24782   if (NILP (Vdisplay_line_numbers))
 24783     return false;
 24784 
 24785   /* Don't display line numbers in minibuffer windows.  */
 24786   if (MINI_WINDOW_P (it->w))
 24787     return false;
 24788 
 24789 #ifdef HAVE_WINDOW_SYSTEM
 24790   /* Don't display line number in tooltip frames.  */
 24791   if (FRAME_TOOLTIP_P (XFRAME (WINDOW_FRAME (it->w))))
 24792     return false;
 24793 #endif
 24794 
 24795   /* If the character at current position has a non-nil special
 24796      property, disable line numbers for this row.  This is for
 24797      packages such as company-mode, which need this for their tricky
 24798      layout, where line numbers get in the way.  */
 24799   Lisp_Object val = Fget_char_property (make_fixnum (IT_CHARPOS (*it)),
 24800                                         Qdisplay_line_numbers_disable,
 24801                                         it->window);
 24802   /* For ZV, we need to also look in empty overlays at that point,
 24803      because get-char-property always returns nil for ZV, except if
 24804      the property is in 'default-text-properties'.  */
 24805   if (NILP (val) && IT_CHARPOS (*it) >= ZV)
 24806     val = disable_line_numbers_overlay_at_eob ();
 24807   return NILP (val) ? true : false;
 24808 }
 24809 
 24810 /* Return true if ROW has no glyphs except those inserted by the
 24811    display engine.  This is needed for indicate-empty-lines and
 24812    similar features when the glyph row starts with glyphs which didn't
 24813    come from buffer or string.  */
 24814 static bool
 24815 row_text_area_empty (struct glyph_row *row)
 24816 {
 24817   if (!row->reversed_p)
 24818     {
 24819       for (struct glyph *g = row->glyphs[TEXT_AREA];
 24820            g < row->glyphs[TEXT_AREA] + row->used[TEXT_AREA];
 24821            g++)
 24822         if (!NILP (g->object) || g->charpos > 0)
 24823           return false;
 24824     }
 24825   else
 24826     {
 24827       for (struct glyph *g = row->glyphs[TEXT_AREA] + row->used[TEXT_AREA] - 1;
 24828            g > row->glyphs[TEXT_AREA];
 24829            g--)
 24830         if (!NILP ((g - 1)->object) || (g - 1)->charpos > 0)
 24831           return false;
 24832     }
 24833 
 24834   return true;
 24835 }
 24836 
 24837 /* Construct the glyph row IT->glyph_row in the desired matrix of
 24838    IT->w from text at the current position of IT.  See dispextern.h
 24839    for an overview of struct it.  Value is true if
 24840    IT->glyph_row displays text, as opposed to a line displaying ZV
 24841    only.  CURSOR_VPOS is the window-relative vertical position of
 24842    the glyph row displaying the cursor, or -1 if unknown.  */
 24843 
 24844 static bool
 24845 display_line (struct it *it, int cursor_vpos)
 24846 {
 24847   struct glyph_row *row = it->glyph_row;
 24848   Lisp_Object overlay_arrow_string;
 24849   struct it wrap_it;
 24850   void *wrap_data = NULL;
 24851   bool may_wrap = false;
 24852   int wrap_x UNINIT;
 24853   int wrap_row_used = -1;
 24854   int wrap_row_ascent UNINIT, wrap_row_height UNINIT;
 24855   int wrap_row_phys_ascent UNINIT, wrap_row_phys_height UNINIT;
 24856   int wrap_row_extra_line_spacing UNINIT;
 24857   ptrdiff_t wrap_row_min_pos UNINIT, wrap_row_min_bpos UNINIT;
 24858   ptrdiff_t wrap_row_max_pos UNINIT, wrap_row_max_bpos UNINIT;
 24859   int cvpos;
 24860   ptrdiff_t min_pos = ZV + 1, max_pos = 0;
 24861   ptrdiff_t min_bpos UNINIT, max_bpos UNINIT;
 24862   bool pending_handle_line_prefix = false;
 24863   int tab_line = window_wants_tab_line (it->w);
 24864   int header_line = window_wants_header_line (it->w);
 24865   bool hscroll_this_line = (cursor_vpos >= 0
 24866                             && it->vpos == cursor_vpos - tab_line - header_line
 24867                             && hscrolling_current_line_p (it->w));
 24868   int first_visible_x = it->first_visible_x;
 24869   int last_visible_x = it->last_visible_x;
 24870   int x_incr = 0;
 24871 
 24872   /* We always start displaying at hpos zero even if hscrolled.  */
 24873   eassert (it->hpos == 0 && it->current_x == 0);
 24874 
 24875   if (MATRIX_ROW_VPOS (row, it->w->desired_matrix)
 24876       >= it->w->desired_matrix->nrows)
 24877     {
 24878       it->w->nrows_scale_factor++;
 24879       it->f->fonts_changed = true;
 24880       return false;
 24881     }
 24882 
 24883   /* Clear the result glyph row and enable it.  */
 24884   prepare_desired_row (it->w, row, false);
 24885 
 24886   row->y = it->current_y;
 24887   row->start = it->start;
 24888   row->continuation_lines_width = it->continuation_lines_width;
 24889   row->displays_text_p = true;
 24890   row->starts_in_middle_of_char_p = it->starts_in_middle_of_char_p;
 24891   it->starts_in_middle_of_char_p = false;
 24892   it->stretch_adjust = 0;
 24893   it->line_number_produced_p = false;
 24894 
 24895   /* If we are going to display the cursor's line, account for the
 24896      hscroll of that line.  We subtract the window's min_hscroll,
 24897      because that was already accounted for in init_iterator.  */
 24898   if (hscroll_this_line)
 24899     x_incr =
 24900       (window_hscroll_limited (it->w, it->f) - it->w->min_hscroll)
 24901       * FRAME_COLUMN_WIDTH (it->f);
 24902 
 24903   bool line_number_needed = should_produce_line_number (it);
 24904 
 24905   /* Move over display elements that are not visible because we are
 24906      hscrolled.  This may stop at an x-position < first_visible_x
 24907      if the first glyph is partially visible or if we hit a line end.  */
 24908   if (it->current_x < it->first_visible_x + x_incr)
 24909     {
 24910       enum move_it_result move_result;
 24911 
 24912       this_line_min_pos = row->start.pos;
 24913       if (hscroll_this_line)
 24914         {
 24915           it->first_visible_x += x_incr;
 24916           it->last_visible_x  += x_incr;
 24917         }
 24918       if (current_buffer->long_line_optimizations_p
 24919           && it->line_wrap == TRUNCATE
 24920           && window_hscroll_limited (it->w, it->f) > large_hscroll_threshold)
 24921         {
 24922           /* Special optimization for very long and truncated lines
 24923              which are hscrolled far to the left: jump directly to the
 24924              (approximate) position that is visible, instead of slowly
 24925              walking there.  */
 24926           ptrdiff_t chars_to_skip =
 24927             it->first_visible_x / FRAME_COLUMN_WIDTH (it->f);
 24928           move_result = fast_move_it_horizontally (it, chars_to_skip);
 24929 
 24930           if (move_result == MOVE_X_REACHED)
 24931             it->current_x = it->first_visible_x;
 24932           else  /* use arbitrary value < first_visible_x */
 24933             it->current_x = it->first_visible_x - FRAME_COLUMN_WIDTH (it->f);
 24934         }
 24935       else
 24936         move_result = move_it_in_display_line_to (it, ZV, it->first_visible_x,
 24937                                                   MOVE_TO_POS | MOVE_TO_X);
 24938       /* If we are under a large hscroll, move_it_in_display_line_to
 24939          could hit the end of the line without reaching
 24940          first_visible_x.  Pretend that we did reach it.  This is
 24941          especially important on a TTY, where we will call
 24942          extend_face_to_end_of_line, which needs to know how many
 24943          blank glyphs to produce.  */
 24944       if (it->current_x < it->first_visible_x
 24945           && (move_result == MOVE_NEWLINE_OR_CR
 24946               || move_result == MOVE_POS_MATCH_OR_ZV))
 24947         it->current_x = it->first_visible_x;
 24948 
 24949       /* In case move_it_in_display_line_to above "produced" the line
 24950          number.  */
 24951       it->line_number_produced_p = false;
 24952 
 24953       /* Record the smallest positions seen while we moved over
 24954          display elements that are not visible.  This is needed by
 24955          redisplay_internal for optimizing the case where the cursor
 24956          stays inside the same line.  The rest of this function only
 24957          considers positions that are actually displayed, so
 24958          RECORD_MAX_MIN_POS will not otherwise record positions that
 24959          are hscrolled to the left of the left edge of the window.  */
 24960       min_pos = CHARPOS (this_line_min_pos);
 24961       min_bpos = BYTEPOS (this_line_min_pos);
 24962 
 24963       /* Produce line number, if needed.  */
 24964       if (line_number_needed)
 24965         maybe_produce_line_number (it);
 24966     }
 24967   else if (it->area == TEXT_AREA)
 24968     {
 24969       /* Line numbers should precede the line-prefix or wrap-prefix.  */
 24970       if (line_number_needed)
 24971         maybe_produce_line_number (it);
 24972 
 24973       /* We only do this when not calling move_it_in_display_line_to
 24974          above, because that function calls itself handle_line_prefix.  */
 24975       handle_line_prefix (it);
 24976     }
 24977   else
 24978     {
 24979       /* Line-prefix and wrap-prefix are always displayed in the text
 24980          area.  But if this is the first call to display_line after
 24981          init_iterator, the iterator might have been set up to write
 24982          into a marginal area, e.g. if the line begins with some
 24983          display property that writes to the margins.  So we need to
 24984          wait with the call to handle_line_prefix until whatever
 24985          writes to the margin has done its job.  */
 24986       pending_handle_line_prefix = true;
 24987     }
 24988 
 24989   /* Get the initial row height.  This is either the height of the
 24990      text hscrolled, if there is any, or zero.  */
 24991   row->ascent = it->max_ascent;
 24992   row->height = it->max_ascent + it->max_descent;
 24993   row->phys_ascent = it->max_phys_ascent;
 24994   row->phys_height = it->max_phys_ascent + it->max_phys_descent;
 24995   row->extra_line_spacing = it->max_extra_line_spacing;
 24996 
 24997 /* Utility macro to record max and min buffer positions seen until now.  */
 24998 #define RECORD_MAX_MIN_POS(IT)                                  \
 24999   do                                                            \
 25000     {                                                           \
 25001       bool composition_p                                        \
 25002         = !STRINGP ((IT)->string) && ((IT)->what == IT_COMPOSITION); \
 25003       ptrdiff_t current_pos =                                   \
 25004         composition_p ? (IT)->cmp_it.charpos                    \
 25005                       : IT_CHARPOS (*(IT));                     \
 25006       ptrdiff_t current_bpos =                                  \
 25007         composition_p ? CHAR_TO_BYTE (current_pos)              \
 25008                       : IT_BYTEPOS (*(IT));                     \
 25009       if (current_pos < min_pos)                                \
 25010         {                                                       \
 25011           min_pos = current_pos;                                \
 25012           min_bpos = current_bpos;                              \
 25013         }                                                       \
 25014       if (IT_CHARPOS (*it) > max_pos)                           \
 25015         {                                                       \
 25016           max_pos = IT_CHARPOS (*it);                           \
 25017           max_bpos = IT_BYTEPOS (*it);                          \
 25018         }                                                       \
 25019     }                                                           \
 25020   while (false)
 25021 
 25022   /* Loop generating characters.  The loop is left with IT on the next
 25023      character to display.  */
 25024   while (true)
 25025     {
 25026       int n_glyphs_before, hpos_before, x_before;
 25027       int x, nglyphs;
 25028       int ascent = 0, descent = 0, phys_ascent = 0, phys_descent = 0;
 25029 
 25030       /* Retrieve the next thing to display.  Value is false if end of
 25031          buffer reached.  */
 25032       if (!get_next_display_element (it))
 25033         {
 25034           bool row_has_glyphs = false;
 25035           /* Maybe add a space at the end of this line that is used to
 25036              display the cursor there under X.  Set the charpos of the
 25037              first glyph of blank lines not corresponding to any text
 25038              to -1.  */
 25039           if (IT_OVERFLOW_NEWLINE_INTO_FRINGE (it))
 25040             row->exact_window_width_line_p = true;
 25041           else if ((append_space_for_newline (it, true)
 25042                     && row->used[TEXT_AREA] == 1)
 25043                    || row->used[TEXT_AREA] == 0
 25044                    || (row_has_glyphs = row_text_area_empty (row)))
 25045             {
 25046               row->glyphs[TEXT_AREA]->charpos = -1;
 25047               /* Don't reset the displays_text_p flag if we are
 25048                  displaying line numbers or line-prefix.  */
 25049               if (!row_has_glyphs)
 25050                 row->displays_text_p = false;
 25051 
 25052               if (!NILP (BVAR (XBUFFER (it->w->contents), indicate_empty_lines))
 25053                   && (!MINI_WINDOW_P (it->w)))
 25054                 row->indicate_empty_line_p = true;
 25055             }
 25056 
 25057           it->continuation_lines_width = 0;
 25058           /* Reset those iterator values set from display property
 25059              values.  This is for the case when the display property
 25060              ends at ZV, and is not a replacing property, so pop_it is
 25061              not called.  */
 25062           it->font_height = Qnil;
 25063           it->voffset = 0;
 25064           row->ends_at_zv_p = true;
 25065           /* A row that displays right-to-left text must always have
 25066              its last face extended all the way to the end of line,
 25067              even if this row ends in ZV, because we still write to
 25068              the screen left to right.  We also need to extend the
 25069              last face if the default face is remapped to some
 25070              different face, otherwise the functions that clear
 25071              portions of the screen will clear with the default face's
 25072              background color.  */
 25073           if (row->reversed_p
 25074               || lookup_basic_face (it->w, it->f, DEFAULT_FACE_ID)
 25075               != DEFAULT_FACE_ID)
 25076             extend_face_to_end_of_line (it);
 25077           break;
 25078         }
 25079 
 25080       /* Now, get the metrics of what we want to display.  This also
 25081          generates glyphs in `row' (which is IT->glyph_row).  */
 25082       n_glyphs_before = row->used[TEXT_AREA];
 25083       x = it->current_x;
 25084 
 25085       /* Remember the line height so far in case the next element doesn't
 25086          fit on the line.  */
 25087       if (it->line_wrap != TRUNCATE)
 25088         {
 25089           ascent = it->max_ascent;
 25090           descent = it->max_descent;
 25091           phys_ascent = it->max_phys_ascent;
 25092           phys_descent = it->max_phys_descent;
 25093 
 25094           if (it->line_wrap == WORD_WRAP && it->area == TEXT_AREA)
 25095             {
 25096               bool next_may_wrap = may_wrap;
 25097               /* Can we wrap after this character?  */
 25098               if (char_can_wrap_after (it))
 25099                 next_may_wrap = true;
 25100               else
 25101                 next_may_wrap = false;
 25102               /* Can we wrap here? */
 25103               if (may_wrap && char_can_wrap_before (it))
 25104                 {
 25105                   SAVE_IT (wrap_it, *it, wrap_data);
 25106                   wrap_x = x;
 25107                   wrap_row_used = row->used[TEXT_AREA];
 25108                   wrap_row_ascent = row->ascent;
 25109                   wrap_row_height = row->height;
 25110                   wrap_row_phys_ascent = row->phys_ascent;
 25111                   wrap_row_phys_height = row->phys_height;
 25112                   wrap_row_extra_line_spacing = row->extra_line_spacing;
 25113                   wrap_row_min_pos = min_pos;
 25114                   wrap_row_min_bpos = min_bpos;
 25115                   wrap_row_max_pos = max_pos;
 25116                   wrap_row_max_bpos = max_bpos;
 25117                 }
 25118               /* Update may_wrap for the next iteration.  */
 25119               may_wrap = next_may_wrap;
 25120             }
 25121         }
 25122 
 25123       PRODUCE_GLYPHS (it);
 25124 
 25125       /* If this display element was in marginal areas, continue with
 25126          the next one.  */
 25127       if (it->area != TEXT_AREA)
 25128         {
 25129           row->ascent = max (row->ascent, it->max_ascent);
 25130           row->height = max (row->height, it->max_ascent + it->max_descent);
 25131           row->phys_ascent = max (row->phys_ascent, it->max_phys_ascent);
 25132           row->phys_height = max (row->phys_height,
 25133                                   it->max_phys_ascent + it->max_phys_descent);
 25134           row->extra_line_spacing = max (row->extra_line_spacing,
 25135                                          it->max_extra_line_spacing);
 25136           set_iterator_to_next (it, true);
 25137           /* If we didn't handle the line/wrap prefix above, and the
 25138              call to set_iterator_to_next just switched to TEXT_AREA,
 25139              process the prefix now.  */
 25140           if (it->area == TEXT_AREA && pending_handle_line_prefix)
 25141             {
 25142               /* Line numbers should precede the line-prefix or wrap-prefix.  */
 25143               if (line_number_needed)
 25144                 maybe_produce_line_number (it);
 25145 
 25146               pending_handle_line_prefix = false;
 25147               handle_line_prefix (it);
 25148             }
 25149           continue;
 25150         }
 25151 
 25152       /* Does the display element fit on the line?  If we truncate
 25153          lines, we should draw past the right edge of the window.  If
 25154          we don't truncate, we want to stop so that we can display the
 25155          continuation glyph before the right margin.  If lines are
 25156          continued, there are two possible strategies for characters
 25157          resulting in more than 1 glyph (e.g. tabs): Display as many
 25158          glyphs as possible in this line and leave the rest for the
 25159          continuation line, or display the whole element in the next
 25160          line.  Original redisplay did the former, so we do it also.  */
 25161       nglyphs = row->used[TEXT_AREA] - n_glyphs_before;
 25162       hpos_before = it->hpos;
 25163       x_before = x;
 25164 
 25165       if (/* Not a newline.  */
 25166           nglyphs > 0
 25167           /* Glyphs produced fit entirely in the line.  */
 25168           && it->current_x < it->last_visible_x)
 25169         {
 25170           it->hpos += nglyphs;
 25171           row->ascent = max (row->ascent, it->max_ascent);
 25172           row->height = max (row->height, it->max_ascent + it->max_descent);
 25173           row->phys_ascent = max (row->phys_ascent, it->max_phys_ascent);
 25174           row->phys_height = max (row->phys_height,
 25175                                   it->max_phys_ascent + it->max_phys_descent);
 25176           row->extra_line_spacing = max (row->extra_line_spacing,
 25177                                          it->max_extra_line_spacing);
 25178           if (it->current_x - it->pixel_width < it->first_visible_x
 25179               /* When line numbers are displayed, row->x should not be
 25180                  offset, as the first glyph after the line number can
 25181                  never be partially visible.  */
 25182               && !line_number_needed
 25183               /* In R2L rows, we arrange in extend_face_to_end_of_line
 25184                  to add a right offset to the line, by a suitable
 25185                  change to the stretch glyph that is the leftmost
 25186                  glyph of the line.  */
 25187               && !row->reversed_p)
 25188             row->x = x - it->first_visible_x;
 25189           /* Record the maximum and minimum buffer positions seen so
 25190              far in glyphs that will be displayed by this row.  */
 25191           if (it->bidi_p)
 25192             RECORD_MAX_MIN_POS (it);
 25193         }
 25194       else
 25195         {
 25196           int i, new_x;
 25197           struct glyph *glyph;
 25198 
 25199           for (i = 0; i < nglyphs; ++i, x = new_x)
 25200             {
 25201               /* Identify the glyphs added by the last call to
 25202                  PRODUCE_GLYPHS.  In R2L rows, they are prepended to
 25203                  the previous glyphs.  */
 25204               if (!row->reversed_p)
 25205                 glyph = row->glyphs[TEXT_AREA] + n_glyphs_before + i;
 25206               else
 25207                 glyph = row->glyphs[TEXT_AREA] + nglyphs - 1 - i;
 25208               new_x = x + glyph->pixel_width;
 25209 
 25210               if (/* Lines are continued.  */
 25211                   it->line_wrap != TRUNCATE
 25212                   && (/* Glyph doesn't fit on the line.  */
 25213                       new_x > it->last_visible_x
 25214                       /* Or it fits exactly on a window system frame.  */
 25215                       || (new_x == it->last_visible_x
 25216                           && FRAME_WINDOW_P (it->f)
 25217                           && (row->reversed_p
 25218                               ? WINDOW_LEFT_FRINGE_WIDTH (it->w)
 25219                               : WINDOW_RIGHT_FRINGE_WIDTH (it->w)))))
 25220                 {
 25221                   /* End of a continued line.  */
 25222 
 25223                   if (it->hpos == 0
 25224                       || (new_x == it->last_visible_x
 25225                           && FRAME_WINDOW_P (it->f)
 25226                           && (row->reversed_p
 25227                               ? WINDOW_LEFT_FRINGE_WIDTH (it->w)
 25228                               : WINDOW_RIGHT_FRINGE_WIDTH (it->w))))
 25229                     {
 25230                       /* Current glyph is the only one on the line or
 25231                          fits exactly on the line.  We must continue
 25232                          the line because we can't draw the cursor
 25233                          after the glyph.  */
 25234                       row->continued_p = true;
 25235                       it->current_x = new_x;
 25236                       it->continuation_lines_width += new_x;
 25237                       ++it->hpos;
 25238                       if (i == nglyphs - 1)
 25239                         {
 25240                           /* If line-wrap is on, check if a previous
 25241                              wrap point was found.  */
 25242                           if (!IT_OVERFLOW_NEWLINE_INTO_FRINGE (it)
 25243                               && wrap_row_used > 0 /* Found.  */
 25244                               /* Even if there is a previous wrap
 25245                                  point, continue the line here as
 25246                                  usual, if (i) the previous character
 25247                                  allows wrapping after it, AND (ii)
 25248                                  the current character allows wrapping
 25249                                  before it.  Because this is a valid
 25250                                  break point, we can just continue to
 25251                                  the next line at here, there is no
 25252                                  need to wrap early at the previous
 25253                                  wrap point.  */
 25254                               && (!may_wrap || !char_can_wrap_before (it)))
 25255                             goto back_to_wrap;
 25256 
 25257                           /* Record the maximum and minimum buffer
 25258                              positions seen so far in glyphs that will be
 25259                              displayed by this row.  */
 25260                           if (it->bidi_p)
 25261                             RECORD_MAX_MIN_POS (it);
 25262                           set_iterator_to_next (it, true);
 25263                           if (IT_OVERFLOW_NEWLINE_INTO_FRINGE (it))
 25264                             {
 25265                               if (!get_next_display_element (it))
 25266                                 {
 25267                                   row->exact_window_width_line_p = true;
 25268                                   it->continuation_lines_width = 0;
 25269                                   it->font_height = Qnil;
 25270                                   it->voffset = 0;
 25271                                   row->continued_p = false;
 25272                                   row->ends_at_zv_p = true;
 25273                                 }
 25274                               else if (ITERATOR_AT_END_OF_LINE_P (it))
 25275                                 {
 25276                                   row->continued_p = false;
 25277                                   row->exact_window_width_line_p = true;
 25278                                 }
 25279                               /* If line-wrap is on, check if a
 25280                                  previous wrap point was found.  */
 25281                               else if (wrap_row_used > 0
 25282                                        /* Even if there is a previous
 25283                                           wrap point, continue the
 25284                                           line here as usual, if (i)
 25285                                           the previous character was a
 25286                                           space or tab AND (ii) the
 25287                                           current character is not,
 25288                                           AND (iii) the current
 25289                                           character allows wrapping
 25290                                           before it.  */
 25291                                        && (!may_wrap || !char_can_wrap_before (it)))
 25292                                 goto back_to_wrap;
 25293 
 25294                             }
 25295                         }
 25296                       else if (it->bidi_p)
 25297                         RECORD_MAX_MIN_POS (it);
 25298                       if (WINDOW_LEFT_MARGIN_WIDTH (it->w) > 0
 25299                           || WINDOW_RIGHT_MARGIN_WIDTH (it->w) > 0)
 25300                         extend_face_to_end_of_line (it);
 25301                     }
 25302                   else if (CHAR_GLYPH_PADDING_P (*glyph)
 25303                            && !FRAME_WINDOW_P (it->f))
 25304                     {
 25305                       /* A padding glyph that doesn't fit on this line.
 25306                          This means the whole character doesn't fit
 25307                          on the line.  */
 25308                       if (row->reversed_p)
 25309                         unproduce_glyphs (it, row->used[TEXT_AREA]
 25310                                                - n_glyphs_before);
 25311                       row->used[TEXT_AREA] = n_glyphs_before;
 25312 
 25313                       /* Fill the rest of the row with continuation
 25314                          glyphs like in 20.x.  */
 25315                       while (row->glyphs[TEXT_AREA] + row->used[TEXT_AREA]
 25316                              < row->glyphs[1 + TEXT_AREA])
 25317                         produce_special_glyphs (it, IT_CONTINUATION);
 25318 
 25319                       row->continued_p = true;
 25320                       it->current_x = x_before;
 25321                       it->continuation_lines_width += x_before;
 25322 
 25323                       /* Restore the height to what it was before the
 25324                          element not fitting on the line.  */
 25325                       it->max_ascent = ascent;
 25326                       it->max_descent = descent;
 25327                       it->max_phys_ascent = phys_ascent;
 25328                       it->max_phys_descent = phys_descent;
 25329                       if (WINDOW_LEFT_MARGIN_WIDTH (it->w) > 0
 25330                           || WINDOW_RIGHT_MARGIN_WIDTH (it->w) > 0)
 25331                         extend_face_to_end_of_line (it);
 25332                     }
 25333                   else if (wrap_row_used > 0)
 25334                     {
 25335                     back_to_wrap:
 25336                       if (row->reversed_p)
 25337                         unproduce_glyphs (it,
 25338                                           row->used[TEXT_AREA] - wrap_row_used);
 25339                       RESTORE_IT (it, &wrap_it, wrap_data);
 25340                       it->continuation_lines_width += wrap_x;
 25341                       row->used[TEXT_AREA] = wrap_row_used;
 25342                       row->ascent = wrap_row_ascent;
 25343                       row->height = wrap_row_height;
 25344                       row->phys_ascent = wrap_row_phys_ascent;
 25345                       row->phys_height = wrap_row_phys_height;
 25346                       row->extra_line_spacing = wrap_row_extra_line_spacing;
 25347                       min_pos = wrap_row_min_pos;
 25348                       min_bpos = wrap_row_min_bpos;
 25349                       max_pos = wrap_row_max_pos;
 25350                       max_bpos = wrap_row_max_bpos;
 25351                       row->continued_p = true;
 25352                       row->ends_at_zv_p = false;
 25353                       row->exact_window_width_line_p = false;
 25354 
 25355                       /* Make sure that a non-default face is extended
 25356                          up to the right margin of the window.  */
 25357                       extend_face_to_end_of_line (it);
 25358                     }
 25359                   else if ((it->what == IT_CHARACTER
 25360                             || it->what == IT_STRETCH
 25361                             || it->what == IT_COMPOSITION)
 25362                            && it->c == '\t' && FRAME_WINDOW_P (it->f))
 25363                     {
 25364                       /* A TAB that extends past the right edge of the
 25365                          window.  This produces a single glyph on
 25366                          window system frames.  We leave the glyph in
 25367                          this row and let it fill the row, but don't
 25368                          consume the TAB.  */
 25369                       if ((row->reversed_p
 25370                            ? WINDOW_LEFT_FRINGE_WIDTH (it->w)
 25371                            : WINDOW_RIGHT_FRINGE_WIDTH (it->w)) == 0)
 25372                         produce_special_glyphs (it, IT_CONTINUATION);
 25373                       it->continuation_lines_width += it->last_visible_x;
 25374                       row->ends_in_middle_of_char_p = true;
 25375                       row->continued_p = true;
 25376                       glyph->pixel_width = it->last_visible_x - x;
 25377                       it->starts_in_middle_of_char_p = true;
 25378                       if (WINDOW_LEFT_MARGIN_WIDTH (it->w) > 0
 25379                           || WINDOW_RIGHT_MARGIN_WIDTH (it->w) > 0)
 25380                         extend_face_to_end_of_line (it);
 25381                     }
 25382                   else
 25383                     {
 25384                       /* Something other than a TAB that draws past
 25385                          the right edge of the window.  Restore
 25386                          positions to values before the element.  */
 25387                       if (row->reversed_p)
 25388                         unproduce_glyphs (it, row->used[TEXT_AREA]
 25389                                                - (n_glyphs_before + i));
 25390                       row->used[TEXT_AREA] = n_glyphs_before + i;
 25391 
 25392                       /* Display continuation glyphs.  */
 25393                       it->current_x = x_before;
 25394                       it->continuation_lines_width += x;
 25395                       if (!FRAME_WINDOW_P (it->f)
 25396                           || (row->reversed_p
 25397                               ? WINDOW_LEFT_FRINGE_WIDTH (it->w)
 25398                               : WINDOW_RIGHT_FRINGE_WIDTH (it->w)) == 0)
 25399                         produce_special_glyphs (it, IT_CONTINUATION);
 25400                       row->continued_p = true;
 25401 
 25402                       extend_face_to_end_of_line (it);
 25403 
 25404                       if (nglyphs > 1 && i > 0)
 25405                         {
 25406                           row->ends_in_middle_of_char_p = true;
 25407                           it->starts_in_middle_of_char_p = true;
 25408                         }
 25409 
 25410                       /* Restore the height to what it was before the
 25411                          element not fitting on the line.  */
 25412                       it->max_ascent = ascent;
 25413                       it->max_descent = descent;
 25414                       it->max_phys_ascent = phys_ascent;
 25415                       it->max_phys_descent = phys_descent;
 25416                     }
 25417 
 25418                   break;
 25419                 }
 25420               else if (new_x > it->first_visible_x)
 25421                 {
 25422                   /* Increment number of glyphs actually displayed.  */
 25423                   ++it->hpos;
 25424 
 25425                   /* Record the maximum and minimum buffer positions
 25426                      seen so far in glyphs that will be displayed by
 25427                      this row.  */
 25428                   if (it->bidi_p)
 25429                     RECORD_MAX_MIN_POS (it);
 25430 
 25431                   if (x < it->first_visible_x && !row->reversed_p
 25432                       && !line_number_needed)
 25433                     /* Glyph is partially visible, i.e. row starts at
 25434                        negative X position.  Don't do that in R2L
 25435                        rows, where we arrange to add a right offset to
 25436                        the line in extend_face_to_end_of_line, by a
 25437                        suitable change to the stretch glyph that is
 25438                        the leftmost glyph of the line.  */
 25439                     row->x = x - it->first_visible_x;
 25440                   /* When the last glyph of an R2L row only fits
 25441                      partially on the line, we need to set row->x to a
 25442                      negative offset, so that the leftmost glyph is
 25443                      the one that is partially visible.  But if we are
 25444                      going to produce the truncation glyph, this will
 25445                      be taken care of in produce_special_glyphs.  */
 25446                   if (row->reversed_p
 25447                       && new_x > it->last_visible_x
 25448                       && !line_number_needed
 25449                       && !(it->line_wrap == TRUNCATE
 25450                            && WINDOW_LEFT_FRINGE_WIDTH (it->w) == 0))
 25451                     {
 25452                       eassert (FRAME_WINDOW_P (it->f));
 25453                       row->x = it->last_visible_x - new_x;
 25454                     }
 25455                 }
 25456               else
 25457                 {
 25458                   /* Glyph is completely off the left margin of the
 25459                      window.  This should not happen because of the
 25460                      move_it_in_display_line at the start of this
 25461                      function, unless the text display area of the
 25462                      window is empty.  */
 25463                   eassert (it->first_visible_x <= it->last_visible_x);
 25464                 }
 25465             }
 25466           /* Even if this display element produced no glyphs at all,
 25467              we want to record its position.  */
 25468           if (it->bidi_p && nglyphs == 0)
 25469             RECORD_MAX_MIN_POS (it);
 25470 
 25471           row->ascent = max (row->ascent, it->max_ascent);
 25472           row->height = max (row->height, it->max_ascent + it->max_descent);
 25473           row->phys_ascent = max (row->phys_ascent, it->max_phys_ascent);
 25474           row->phys_height = max (row->phys_height,
 25475                                   it->max_phys_ascent + it->max_phys_descent);
 25476           row->extra_line_spacing = max (row->extra_line_spacing,
 25477                                          it->max_extra_line_spacing);
 25478 
 25479           /* End of this display line if row is continued.  */
 25480           if (row->continued_p || row->ends_at_zv_p)
 25481             break;
 25482         }
 25483 
 25484     at_end_of_line:
 25485       /* Is this a line end?  If yes, we're also done, after making
 25486          sure that a non-default face is extended up to the right
 25487          margin of the window.  */
 25488       if (ITERATOR_AT_END_OF_LINE_P (it))
 25489         {
 25490           int used_before = row->used[TEXT_AREA];
 25491 
 25492           row->ends_in_newline_from_string_p = STRINGP (it->object);
 25493 
 25494           /* Add a space at the end of the line that is used to
 25495              display the cursor there.  */
 25496           if (!IT_OVERFLOW_NEWLINE_INTO_FRINGE (it))
 25497             append_space_for_newline (it, false);
 25498 
 25499           /* Extend the face to the end of the line.  */
 25500           extend_face_to_end_of_line (it);
 25501 
 25502           /* Make sure we have the position.  */
 25503           if (used_before == 0)
 25504             row->glyphs[TEXT_AREA]->charpos = CHARPOS (it->position);
 25505 
 25506           /* Record the position of the newline, for use in
 25507              find_row_edges.  */
 25508           it->eol_pos = it->current.pos;
 25509 
 25510           /* Consume the line end.  This skips over invisible lines.  */
 25511           set_iterator_to_next (it, true);
 25512           it->continuation_lines_width = 0;
 25513           break;
 25514         }
 25515 
 25516       /* Detect overly-wide wrap-prefixes made of (space ...) display
 25517          properties.  When such a wrap prefix reaches past the right
 25518          margin of the window, we need to avoid the call to
 25519          set_iterator_to_next below, so that it->line_wrap is left at
 25520          its TRUNCATE value wisely set by handle_line_prefix.
 25521          Otherwise, set_iterator_to_next will pop the iterator stack,
 25522          restore it->line_wrap, and redisplay might infloop.  */
 25523       bool overwide_wrap_prefix =
 25524         CONSP (it->object) && EQ (XCAR (it->object), Qspace)
 25525         && it->sp > 0 && it->method == GET_FROM_STRETCH
 25526         && it->current_x >= it->last_visible_x
 25527         && it->continuation_lines_width > 0
 25528         && it->line_wrap == TRUNCATE && it->stack[0].line_wrap != TRUNCATE;
 25529 
 25530       /* Proceed with next display element.  Note that this skips
 25531          over lines invisible because of selective display.  */
 25532       if (!overwide_wrap_prefix)
 25533         set_iterator_to_next (it, true);
 25534 
 25535       /* If we truncate lines, we are done when the last displayed
 25536          glyphs reach past the right margin of the window.  */
 25537       if (it->line_wrap == TRUNCATE
 25538           && ((FRAME_WINDOW_P (it->f)
 25539                /* Images are preprocessed in produce_image_glyph such
 25540                   that they are cropped at the right edge of the
 25541                   window, so an image glyph will always end exactly at
 25542                   last_visible_x, even if there's no right fringe.  */
 25543                && ((row->reversed_p
 25544                     ? WINDOW_LEFT_FRINGE_WIDTH (it->w)
 25545                     : WINDOW_RIGHT_FRINGE_WIDTH (it->w))
 25546                    || it->what == IT_IMAGE))
 25547               ? (it->current_x >= it->last_visible_x)
 25548               : (it->current_x > it->last_visible_x)))
 25549         {
 25550           /* Maybe add truncation glyphs.  */
 25551           if (!FRAME_WINDOW_P (it->f)
 25552               || (row->reversed_p
 25553                   ? WINDOW_LEFT_FRINGE_WIDTH (it->w)
 25554                   : WINDOW_RIGHT_FRINGE_WIDTH (it->w)) == 0)
 25555             {
 25556               int i, n;
 25557 
 25558               if (!row->reversed_p)
 25559                 {
 25560                   for (i = row->used[TEXT_AREA] - 1; i > 0; --i)
 25561                     if (!CHAR_GLYPH_PADDING_P (row->glyphs[TEXT_AREA][i]))
 25562                       break;
 25563                 }
 25564               else
 25565                 {
 25566                   for (i = 0; i < row->used[TEXT_AREA]; i++)
 25567                     if (!CHAR_GLYPH_PADDING_P (row->glyphs[TEXT_AREA][i]))
 25568                       break;
 25569                   /* Remove any padding glyphs at the front of ROW, to
 25570                      make room for the truncation glyphs we will be
 25571                      adding below.  The loop below always inserts at
 25572                      least one truncation glyph, so also remove the
 25573                      last glyph added to ROW.  */
 25574                   unproduce_glyphs (it, i + 1);
 25575                   /* Adjust i for the loop below.  */
 25576                   i = row->used[TEXT_AREA] - (i + 1);
 25577                 }
 25578 
 25579               /* produce_special_glyphs overwrites the last glyph, so
 25580                  we don't want that if we want to keep that last
 25581                  glyph, which means it's an image.  */
 25582               if (it->current_x > it->last_visible_x)
 25583                 {
 25584                   it->current_x = x_before;
 25585                   if (!FRAME_WINDOW_P (it->f))
 25586                     {
 25587                       for (n = row->used[TEXT_AREA]; i < n; ++i)
 25588                         {
 25589                           row->used[TEXT_AREA] = i;
 25590                           produce_special_glyphs (it, IT_TRUNCATION);
 25591                         }
 25592                     }
 25593                   else
 25594                     {
 25595                       row->used[TEXT_AREA] = i;
 25596                       produce_special_glyphs (it, IT_TRUNCATION);
 25597                     }
 25598                   it->hpos = hpos_before;
 25599                 }
 25600             }
 25601           else if (IT_OVERFLOW_NEWLINE_INTO_FRINGE (it))
 25602             {
 25603               /* Don't truncate if we can overflow newline into fringe.  */
 25604               if (!get_next_display_element (it))
 25605                 {
 25606                   it->continuation_lines_width = 0;
 25607                   it->font_height = Qnil;
 25608                   it->voffset = 0;
 25609                   row->ends_at_zv_p = true;
 25610                   row->exact_window_width_line_p = true;
 25611                   break;
 25612                 }
 25613               if (ITERATOR_AT_END_OF_LINE_P (it))
 25614                 {
 25615                   row->exact_window_width_line_p = true;
 25616                   goto at_end_of_line;
 25617                 }
 25618               it->current_x = x_before;
 25619               it->hpos = hpos_before;
 25620             }
 25621 
 25622           row->truncated_on_right_p = true;
 25623           it->continuation_lines_width = 0;
 25624           reseat_at_next_visible_line_start (it, false);
 25625           /* We insist below that IT's position be at ZV because in
 25626              bidi-reordered lines the character at visible line start
 25627              might not be the character that follows the newline in
 25628              the logical order.  */
 25629           if (IT_BYTEPOS (*it) > BEG_BYTE)
 25630             row->ends_at_zv_p =
 25631               IT_BYTEPOS (*it) >= ZV_BYTE
 25632               && (ZV_BYTE <= 1 || FETCH_BYTE (ZV_BYTE - 1) != '\n');
 25633           else
 25634             row->ends_at_zv_p = false;
 25635           break;
 25636         }
 25637     }
 25638 
 25639   if (wrap_data)
 25640     bidi_unshelve_cache (wrap_data, true);
 25641 
 25642   /* If line is not empty and hscrolled, maybe insert truncation glyphs
 25643      at the left window margin.  */
 25644   if (it->first_visible_x
 25645       && IT_CHARPOS (*it) != CHARPOS (row->start.pos))
 25646     {
 25647       if (!FRAME_WINDOW_P (it->f)
 25648           || (((row->reversed_p
 25649                 ? WINDOW_RIGHT_FRINGE_WIDTH (it->w)
 25650                 : WINDOW_LEFT_FRINGE_WIDTH (it->w)) == 0)
 25651               /* Don't let insert_left_trunc_glyphs overwrite the
 25652                  first glyph of the row if it is an image.  */
 25653               && row->glyphs[TEXT_AREA]->type != IMAGE_GLYPH))
 25654         insert_left_trunc_glyphs (it);
 25655       row->truncated_on_left_p = true;
 25656     }
 25657 
 25658   /* Remember the position at which this line ends.
 25659 
 25660      BIDI Note: any code that needs MATRIX_ROW_START/END_CHARPOS
 25661      cannot be before the call to find_row_edges below, since that is
 25662      where these positions are determined. */
 25663   row->end = it->current;
 25664   if (!it->bidi_p)
 25665     {
 25666       row->minpos = row->start.pos;
 25667       row->maxpos = row->end.pos;
 25668     }
 25669   else
 25670     {
 25671       /* ROW->minpos and ROW->maxpos must be the smallest and
 25672          `1 + the largest' buffer positions in ROW.  But if ROW was
 25673          bidi-reordered, these two positions can be anywhere in the
 25674          row, so we must determine them now.  */
 25675       find_row_edges (it, row, min_pos, min_bpos, max_pos, max_bpos);
 25676     }
 25677 
 25678   /* If the start of this line is the overlay arrow-position, then
 25679      mark this glyph row as the one containing the overlay arrow.
 25680      This is clearly a mess with variable size fonts.  It would be
 25681      better to let it be displayed like cursors under X.  */
 25682   if ((MATRIX_ROW_DISPLAYS_TEXT_P (row) || !overlay_arrow_seen)
 25683       && (overlay_arrow_string = overlay_arrow_at_row (it, row),
 25684           !NILP (overlay_arrow_string)))
 25685     {
 25686       /* Overlay arrow in window redisplay is a fringe bitmap.  */
 25687       if (STRINGP (overlay_arrow_string))
 25688         {
 25689           struct glyph_row *arrow_row
 25690             = get_overlay_arrow_glyph_row (it->w, overlay_arrow_string);
 25691           struct glyph *glyph = arrow_row->glyphs[TEXT_AREA];
 25692           struct glyph *arrow_end = glyph + arrow_row->used[TEXT_AREA];
 25693           struct glyph *p = row->glyphs[TEXT_AREA];
 25694           struct glyph *p2, *end;
 25695 
 25696           /* Copy the arrow glyphs.  */
 25697           while (glyph < arrow_end)
 25698             *p++ = *glyph++;
 25699 
 25700           /* Throw away padding glyphs.  */
 25701           p2 = p;
 25702           end = row->glyphs[TEXT_AREA] + row->used[TEXT_AREA];
 25703           while (p2 < end && CHAR_GLYPH_PADDING_P (*p2))
 25704             ++p2;
 25705           if (p2 > p)
 25706             {
 25707               while (p2 < end)
 25708                 *p++ = *p2++;
 25709               row->used[TEXT_AREA] = p2 - row->glyphs[TEXT_AREA];
 25710             }
 25711         }
 25712       else
 25713         {
 25714           eassert (FIXNUMP (overlay_arrow_string));
 25715           row->overlay_arrow_bitmap = XFIXNUM (overlay_arrow_string);
 25716         }
 25717       overlay_arrow_seen = true;
 25718     }
 25719 
 25720   /* Highlight trailing whitespace.  */
 25721   if (!NILP (Vshow_trailing_whitespace))
 25722     highlight_trailing_whitespace (it);
 25723 
 25724   /* Compute pixel dimensions of this line.  */
 25725   compute_line_metrics (it);
 25726 
 25727   /* Implementation note: No changes in the glyphs of ROW or in their
 25728      faces can be done past this point, because compute_line_metrics
 25729      computes ROW's hash value and stores it within the glyph_row
 25730      structure.  */
 25731 
 25732   /* Record whether this row ends inside an ellipsis.  */
 25733   row->ends_in_ellipsis_p
 25734     = (it->method == GET_FROM_DISPLAY_VECTOR
 25735        && it->ellipsis_p);
 25736 
 25737   /* Save fringe bitmaps in this row.  */
 25738   row->left_user_fringe_bitmap = it->left_user_fringe_bitmap;
 25739   row->left_user_fringe_face_id = it->left_user_fringe_face_id;
 25740   row->right_user_fringe_bitmap = it->right_user_fringe_bitmap;
 25741   row->right_user_fringe_face_id = it->right_user_fringe_face_id;
 25742 
 25743   it->left_user_fringe_bitmap = 0;
 25744   it->left_user_fringe_face_id = 0;
 25745   it->right_user_fringe_bitmap = 0;
 25746   it->right_user_fringe_face_id = 0;
 25747 
 25748   /* When they turn off tooltip-mode on a GUI frame, we call 'message'
 25749      with message-truncate-lines bound to non-nil, which produces
 25750      truncation bitmaps on the fringe.  Force redrawing of the fringes
 25751      in that case, to make sure the fringe bitmaps are removed when a
 25752      shorter message is displayed.  */
 25753   if (MINI_WINDOW_P (it->w) && it->line_wrap == TRUNCATE
 25754       && FRAME_WINDOW_P (it->f) && !cursor_in_echo_area)
 25755     row->redraw_fringe_bitmaps_p = true;
 25756 
 25757   /* Maybe set the cursor.  */
 25758   cvpos = it->w->cursor.vpos;
 25759   if ((cvpos < 0
 25760        /* In bidi-reordered rows, keep checking for proper cursor
 25761           position even if one has been found already, because buffer
 25762           positions in such rows change non-linearly with ROW->VPOS,
 25763           when a line is continued.  One exception: when we are at ZV,
 25764           display cursor on the first suitable glyph row, since all
 25765           the empty rows after that also have their position set to ZV.  */
 25766        /* FIXME: Revisit this when glyph ``spilling'' in continuation
 25767           lines' rows is implemented for bidi-reordered rows.  */
 25768        || (it->bidi_p
 25769            && !MATRIX_ROW (it->w->desired_matrix, cvpos)->ends_at_zv_p))
 25770       && PT >= MATRIX_ROW_START_CHARPOS (row)
 25771       && PT <= MATRIX_ROW_END_CHARPOS (row)
 25772       && cursor_row_p (row))
 25773     set_cursor_from_row (it->w, row, it->w->desired_matrix, 0, 0, 0, 0);
 25774 
 25775   /* Prepare for the next line.  This line starts horizontally at (X
 25776      HPOS) = (0 0).  Vertical positions are incremented.  As a
 25777      convenience for the caller, IT->glyph_row is set to the next
 25778      row to be used.  */
 25779   it->current_x = it->hpos = 0;
 25780   it->current_y += row->height;
 25781   /* Restore the first and last visible X if we adjusted them for
 25782      current-line hscrolling.  */
 25783   if (hscroll_this_line)
 25784     {
 25785       it->first_visible_x = first_visible_x;
 25786       it->last_visible_x  = last_visible_x;
 25787     }
 25788   SET_TEXT_POS (it->eol_pos, 0, 0);
 25789   ++it->vpos;
 25790   ++it->glyph_row;
 25791   /* The next row should by default use the same value of the
 25792      reversed_p flag as this one.  set_iterator_to_next decides when
 25793      it's a new paragraph, and PRODUCE_GLYPHS recomputes the value of
 25794      the flag accordingly.  */
 25795   if (it->glyph_row < MATRIX_BOTTOM_TEXT_ROW (it->w->desired_matrix, it->w))
 25796     it->glyph_row->reversed_p = row->reversed_p;
 25797   it->start = row->end;
 25798   return MATRIX_ROW_DISPLAYS_TEXT_P (row);
 25799 
 25800 #undef RECORD_MAX_MIN_POS
 25801 }
 25802 
 25803 DEFUN ("current-bidi-paragraph-direction", Fcurrent_bidi_paragraph_direction,
 25804        Scurrent_bidi_paragraph_direction, 0, 1, 0,
 25805        doc: /* Return paragraph direction at point in BUFFER.
 25806 Value is either `left-to-right' or `right-to-left'.
 25807 If BUFFER is omitted or nil, it defaults to the current buffer.
 25808 
 25809 Paragraph direction determines how the text in the paragraph is displayed.
 25810 In left-to-right paragraphs, text begins at the left margin of the window
 25811 and the reading direction is generally left to right.  In right-to-left
 25812 paragraphs, text begins at the right margin and is read from right to left.
 25813 
 25814 See also `bidi-paragraph-direction'.  */)
 25815   (Lisp_Object buffer)
 25816 {
 25817   struct buffer *buf = current_buffer;
 25818   struct buffer *old = buf;
 25819 
 25820   if (! NILP (buffer))
 25821     {
 25822       CHECK_BUFFER (buffer);
 25823       buf = XBUFFER (buffer);
 25824     }
 25825 
 25826   if (NILP (BVAR (buf, bidi_display_reordering))
 25827       || NILP (BVAR (buf, enable_multibyte_characters))
 25828       /* When we are loading loadup.el, the character property tables
 25829          needed for bidi iteration are not yet available.  */
 25830       || redisplay__inhibit_bidi)
 25831     return Qleft_to_right;
 25832   else if (!NILP (BVAR (buf, bidi_paragraph_direction)))
 25833     return BVAR (buf, bidi_paragraph_direction);
 25834   else
 25835     {
 25836       /* Determine the direction from buffer text.  We could try to
 25837          use current_matrix if it is up to date, but this seems fast
 25838          enough as it is.  */
 25839       struct bidi_it itb;
 25840       ptrdiff_t pos = BUF_PT (buf);
 25841       ptrdiff_t bytepos = BUF_PT_BYTE (buf);
 25842       int c;
 25843       void *itb_data = bidi_shelve_cache ();
 25844 
 25845       set_buffer_temp (buf);
 25846       /* bidi_paragraph_init finds the base direction of the paragraph
 25847          by searching forward from paragraph start.  We need the base
 25848          direction of the current or _previous_ paragraph, so we need
 25849          to make sure we are within that paragraph.  To that end, find
 25850          the previous non-empty line.  */
 25851       if (pos >= ZV && pos > BEGV)
 25852         dec_both (&pos, &bytepos);
 25853       AUTO_STRING (trailing_white_space, "[\f\t ]*\n");
 25854       if (fast_looking_at (trailing_white_space,
 25855                            pos, bytepos, ZV, ZV_BYTE, Qnil) > 0)
 25856         {
 25857           while ((c = FETCH_BYTE (bytepos)) == '\n'
 25858                  || c == ' ' || c == '\t' || c == '\f')
 25859             {
 25860               if (bytepos <= BEGV_BYTE)
 25861                 break;
 25862               bytepos--;
 25863               pos--;
 25864             }
 25865           while (!CHAR_HEAD_P (FETCH_BYTE (bytepos)))
 25866             bytepos--;
 25867         }
 25868       bidi_init_it (pos, bytepos, FRAME_WINDOW_P (SELECTED_FRAME ()), &itb);
 25869       itb.paragraph_dir = NEUTRAL_DIR;
 25870       itb.string.s = NULL;
 25871       itb.string.lstring = Qnil;
 25872       itb.string.bufpos = 0;
 25873       itb.string.from_disp_str = false;
 25874       itb.string.unibyte = false;
 25875       /* We have no window to use here for ignoring window-specific
 25876          overlays.  Using NULL for window pointer will cause
 25877          compute_display_string_pos to use the current buffer.  */
 25878       itb.w = NULL;
 25879       bidi_paragraph_init (NEUTRAL_DIR, &itb, true);
 25880       bidi_unshelve_cache (itb_data, false);
 25881       set_buffer_temp (old);
 25882       switch (itb.paragraph_dir)
 25883         {
 25884         case L2R:
 25885           return Qleft_to_right;
 25886           break;
 25887         case R2L:
 25888           return Qright_to_left;
 25889           break;
 25890         default:
 25891           emacs_abort ();
 25892         }
 25893     }
 25894 }
 25895 
 25896 DEFUN ("bidi-find-overridden-directionality",
 25897        Fbidi_find_overridden_directionality,
 25898        Sbidi_find_overridden_directionality, 3, 4, 0,
 25899        doc: /* Return position between FROM and TO where directionality was overridden.
 25900 
 25901 This function returns the first character position in the specified
 25902 region of OBJECT where characters have their bidirectional
 25903 properties affected in a way that might make its text look confusingly
 25904 on display.  For example, characters whose `bidi-class' property is `L',
 25905 could be forced to display as `R' by a directional override, and
 25906 likewise characters whose `bidi-class' is `R' or `AL' that are
 25907 forced to display as `L'.
 25908 
 25909 If no such character is found, the function returns nil.
 25910 
 25911 OBJECT is a Lisp string or buffer to search for overridden
 25912 directionality, and defaults to the current buffer if nil.
 25913 OBJECT can also be a window, in which case the function will search
 25914 the buffer displayed in that window.  Passing the window instead of
 25915 a buffer is preferable when the buffer is displayed in some window,
 25916 because this function will then be able to correctly account for
 25917 window-specific overlays, which can affect the results.
 25918 
 25919 Optional argument BASE-DIR specifies the base paragraph directory
 25920 of the text.  It should be a symbol, either `left-to-right'
 25921 or `right-to-left', and defaults to `left-to-right'.
 25922 
 25923 Strong directional characters `L', `R', and `AL' can have their
 25924 intrinsic directionality overridden by directional override control
 25925 characters RLO (u+202E) and LRO (u+202D).  They can also have their
 25926 directionality affected by other formatting control characters: LRE
 25927 (u+202A), RLE (u+202B), LRI (u+2066), and RLI (u+2067).  See the
 25928 function `get-char-code-property' for a way to inquire about the
 25929 `bidi-class' property of a character.  Characters whose intrinsic
 25930 directionality is weak or neutral, such as numbers or punctuation
 25931 characters, can be forced to display in a very different place with
 25932 respect of its surrounding characters, so as to make the surrounding
 25933 text confuse the user regarding what the text says.
 25934 
 25935 Also see the `highlight-confusing-reorderings' function, which can be
 25936 useful in similar circumstances as this function.  */)
 25937   (Lisp_Object from, Lisp_Object to, Lisp_Object object, Lisp_Object base_dir)
 25938 {
 25939   struct buffer *buf = current_buffer;
 25940   struct buffer *old = buf;
 25941   struct window *w = NULL;
 25942   bool frame_window_p = FRAME_WINDOW_P (SELECTED_FRAME ());
 25943   struct bidi_it itb;
 25944   ptrdiff_t from_pos, to_pos, from_bpos;
 25945   void *itb_data;
 25946 
 25947   if (!NILP (object))
 25948     {
 25949       if (BUFFERP (object))
 25950         buf = XBUFFER (object);
 25951       else if (WINDOWP (object))
 25952         {
 25953           w = decode_live_window (object);
 25954           buf = XBUFFER (w->contents);
 25955           frame_window_p = FRAME_WINDOW_P (XFRAME (w->frame));
 25956         }
 25957       else
 25958         CHECK_STRING (object);
 25959     }
 25960 
 25961   if (STRINGP (object))
 25962     {
 25963       /* Characters in unibyte strings are always treated by bidi.c as
 25964          strong LTR.  */
 25965       if (!STRING_MULTIBYTE (object)
 25966           /* When we are loading loadup.el, the character property
 25967              tables needed for bidi iteration are not yet
 25968              available.  */
 25969           || redisplay__inhibit_bidi)
 25970         return Qnil;
 25971 
 25972       validate_subarray (object, from, to, SCHARS (object), &from_pos, &to_pos);
 25973       if (from_pos >= SCHARS (object))
 25974         return Qnil;
 25975 
 25976       /* Set up the bidi iterator.  */
 25977       itb_data = bidi_shelve_cache ();
 25978       itb.paragraph_dir = NEUTRAL_DIR;
 25979       itb.string.lstring = object;
 25980       itb.string.s = NULL;
 25981       itb.string.schars = SCHARS (object);
 25982       itb.string.bufpos = 0;
 25983       itb.string.from_disp_str = false;
 25984       itb.string.unibyte = false;
 25985       itb.w = w;
 25986       bidi_init_it (0, 0, frame_window_p, &itb);
 25987     }
 25988   else
 25989     {
 25990       /* Nothing this fancy can happen in unibyte buffers, or in a
 25991          buffer that disabled reordering, or if FROM is at EOB.  */
 25992       if (NILP (BVAR (buf, bidi_display_reordering))
 25993           || NILP (BVAR (buf, enable_multibyte_characters))
 25994           /* When we are loading loadup.el, the character property
 25995              tables needed for bidi iteration are not yet
 25996              available.  */
 25997           || redisplay__inhibit_bidi)
 25998         return Qnil;
 25999 
 26000       set_buffer_temp (buf);
 26001       validate_region (&from, &to);
 26002       from_pos = XFIXNUM (from);
 26003       to_pos = XFIXNUM (to);
 26004       if (from_pos >= ZV)
 26005         return Qnil;
 26006 
 26007       /* Set up the bidi iterator.  */
 26008       itb_data = bidi_shelve_cache ();
 26009       from_bpos = CHAR_TO_BYTE (from_pos);
 26010       if (from_pos == BEGV)
 26011         {
 26012           itb.charpos = BEGV;
 26013           itb.bytepos = BEGV_BYTE;
 26014         }
 26015       else if (FETCH_BYTE (from_bpos - 1) == '\n')
 26016         {
 26017           itb.charpos = from_pos;
 26018           itb.bytepos = from_bpos;
 26019         }
 26020       else
 26021         itb.charpos = find_newline_no_quit (from_pos, CHAR_TO_BYTE (from_pos),
 26022                                             -1, &itb.bytepos);
 26023       itb.paragraph_dir = NEUTRAL_DIR;
 26024       itb.string.s = NULL;
 26025       itb.string.lstring = Qnil;
 26026       itb.string.bufpos = 0;
 26027       itb.string.from_disp_str = false;
 26028       itb.string.unibyte = false;
 26029       itb.w = w;
 26030       bidi_init_it (itb.charpos, itb.bytepos, frame_window_p, &itb);
 26031     }
 26032 
 26033   ptrdiff_t found;
 26034   bidi_dir_t bdir = EQ (base_dir, Qright_to_left) ? R2L : L2R;
 26035   do {
 26036     bidi_paragraph_init (bdir, &itb, false);
 26037     while ((found = bidi_find_first_overridden (&itb)) < from_pos)
 26038       ;
 26039   } while (found == ZV && itb.ch == '\n' && itb.charpos < to_pos);
 26040 
 26041   bidi_unshelve_cache (itb_data, false);
 26042   set_buffer_temp (old);
 26043 
 26044   return (from_pos <= found && found < to_pos) ? make_fixnum (found) : Qnil;
 26045 }
 26046 
 26047 DEFUN ("move-point-visually", Fmove_point_visually,
 26048        Smove_point_visually, 1, 1, 0,
 26049        doc: /* Move point in the visual order in the specified DIRECTION.
 26050 DIRECTION can be 1, meaning move to the right, or -1, which moves to the
 26051 left.
 26052 
 26053 Value is the new character position of point.  */)
 26054   (Lisp_Object direction)
 26055 {
 26056   struct window *w = XWINDOW (selected_window);
 26057   struct buffer *b = XBUFFER (w->contents);
 26058   struct glyph_row *row;
 26059   int dir;
 26060   Lisp_Object paragraph_dir;
 26061 
 26062 #define ROW_GLYPH_NEWLINE_P(ROW,GLYPH)          \
 26063   (!(ROW)->continued_p                          \
 26064    && NILP ((GLYPH)->object)                    \
 26065    && (GLYPH)->type == CHAR_GLYPH               \
 26066    && (GLYPH)->u.ch == ' '                      \
 26067    && (GLYPH)->charpos >= 0                     \
 26068    && !(GLYPH)->avoid_cursor_p)
 26069 
 26070   CHECK_FIXNUM (direction);
 26071   dir = XFIXNUM (direction);
 26072   if (dir > 0)
 26073     dir = 1;
 26074   else
 26075     dir = -1;
 26076 
 26077   /* If current matrix is up-to-date, we can use the information
 26078      recorded in the glyphs, at least as long as the goal is on the
 26079      screen.  */
 26080   if (w->window_end_valid
 26081       && !windows_or_buffers_changed
 26082       && b
 26083       && !b->clip_changed
 26084       && !b->prevent_redisplay_optimizations_p
 26085       && !window_outdated (w)
 26086       /* We rely below on the cursor coordinates to be up to date, but
 26087          we cannot trust them if some command moved point since the
 26088          last complete redisplay.  */
 26089       && w->last_point == BUF_PT (b)
 26090       && w->cursor.vpos >= 0
 26091       && w->cursor.vpos < w->current_matrix->nrows
 26092       && (row = MATRIX_ROW (w->current_matrix, w->cursor.vpos))->enabled_p)
 26093     {
 26094       struct glyph *g = row->glyphs[TEXT_AREA];
 26095       struct glyph *e = dir > 0 ? g + row->used[TEXT_AREA] : g - 1;
 26096       struct glyph *gpt = g + w->cursor.hpos;
 26097 
 26098       for (g = gpt + dir; (dir > 0 ? g < e : g > e); g += dir)
 26099         {
 26100           if (BUFFERP (g->object) && g->charpos != PT)
 26101             {
 26102               SET_PT (g->charpos);
 26103               w->cursor.vpos = -1;
 26104               return make_fixnum (PT);
 26105             }
 26106           else if (!NILP (g->object) && !EQ (g->object, gpt->object))
 26107             {
 26108               ptrdiff_t new_pos;
 26109 
 26110               if (BUFFERP (gpt->object))
 26111                 {
 26112                   new_pos = PT;
 26113                   if ((gpt->resolved_level - row->reversed_p) % 2 == 0)
 26114                     new_pos += (row->reversed_p ? -dir : dir);
 26115                   else
 26116                     new_pos -= (row->reversed_p ? -dir : dir);
 26117                   new_pos = clip_to_bounds (BEGV, new_pos, ZV);
 26118                   /* If we didn't move, we've hit BEGV or ZV, so we
 26119                      need to signal a suitable error.  */
 26120                   if (new_pos == PT)
 26121                     break;
 26122                 }
 26123               else if (BUFFERP (g->object))
 26124                 new_pos = g->charpos;
 26125               else
 26126                 break;
 26127               SET_PT (new_pos);
 26128               w->cursor.vpos = -1;
 26129               return make_fixnum (PT);
 26130             }
 26131           else if (ROW_GLYPH_NEWLINE_P (row, g))
 26132             {
 26133               /* Glyphs inserted at the end of a non-empty line for
 26134                  positioning the cursor have zero charpos, so we must
 26135                  deduce the value of point by other means.  */
 26136               if (g->charpos > 0)
 26137                 SET_PT (g->charpos);
 26138               else if (row->ends_at_zv_p && PT != ZV)
 26139                 SET_PT (ZV);
 26140               else if (PT != MATRIX_ROW_END_CHARPOS (row) - 1)
 26141                 SET_PT (MATRIX_ROW_END_CHARPOS (row) - 1);
 26142               else
 26143                 break;
 26144               w->cursor.vpos = -1;
 26145               return make_fixnum (PT);
 26146             }
 26147         }
 26148       if (g == e || NILP (g->object))
 26149         {
 26150           if (row->truncated_on_left_p || row->truncated_on_right_p)
 26151             goto simulate_display;
 26152           if (!row->reversed_p)
 26153             row += dir;
 26154           else
 26155             row -= dir;
 26156           if (!(MATRIX_FIRST_TEXT_ROW (w->current_matrix) <= row
 26157                 && row < MATRIX_BOTTOM_TEXT_ROW (w->current_matrix, w)))
 26158             goto simulate_display;
 26159 
 26160           if (dir > 0)
 26161             {
 26162               if (row->reversed_p && !row->continued_p)
 26163                 {
 26164                   SET_PT (MATRIX_ROW_END_CHARPOS (row) - 1);
 26165                   w->cursor.vpos = -1;
 26166                   return make_fixnum (PT);
 26167                 }
 26168               g = row->glyphs[TEXT_AREA];
 26169               e = g + row->used[TEXT_AREA];
 26170               for ( ; g < e; g++)
 26171                 {
 26172                   if (BUFFERP (g->object)
 26173                       /* Empty lines have only one glyph, which stands
 26174                          for the newline, and whose charpos is the
 26175                          buffer position of the newline.  */
 26176                       || ROW_GLYPH_NEWLINE_P (row, g)
 26177                       /* When the buffer ends in a newline, the line at
 26178                          EOB also has one glyph, but its charpos is -1.  */
 26179                       || (row->ends_at_zv_p
 26180                           && !row->reversed_p
 26181                           && NILP (g->object)
 26182                           && g->type == CHAR_GLYPH
 26183                           && g->u.ch == ' '))
 26184                     {
 26185                       if (g->charpos > 0)
 26186                         SET_PT (g->charpos);
 26187                       else if (!row->reversed_p
 26188                                && row->ends_at_zv_p
 26189                                && PT != ZV)
 26190                         SET_PT (ZV);
 26191                       else
 26192                         continue;
 26193                       w->cursor.vpos = -1;
 26194                       return make_fixnum (PT);
 26195                     }
 26196                 }
 26197             }
 26198           else
 26199             {
 26200               if (!row->reversed_p && !row->continued_p)
 26201                 {
 26202                   SET_PT (MATRIX_ROW_END_CHARPOS (row) - 1);
 26203                   w->cursor.vpos = -1;
 26204                   return make_fixnum (PT);
 26205                 }
 26206               e = row->glyphs[TEXT_AREA];
 26207               g = e + row->used[TEXT_AREA] - 1;
 26208               for ( ; g >= e; g--)
 26209                 {
 26210                   if (BUFFERP (g->object)
 26211                       || (ROW_GLYPH_NEWLINE_P (row, g)
 26212                           && g->charpos > 0)
 26213                       /* Empty R2L lines on GUI frames have the buffer
 26214                          position of the newline stored in the stretch
 26215                          glyph.  */
 26216                       || g->type == STRETCH_GLYPH
 26217                       || (row->ends_at_zv_p
 26218                           && row->reversed_p
 26219                           && NILP (g->object)
 26220                           && g->type == CHAR_GLYPH
 26221                           && g->u.ch == ' '))
 26222                     {
 26223                       if (g->charpos > 0)
 26224                         SET_PT (g->charpos);
 26225                       else if (row->reversed_p
 26226                                && row->ends_at_zv_p
 26227                                && PT != ZV)
 26228                         SET_PT (ZV);
 26229                       else
 26230                         continue;
 26231                       w->cursor.vpos = -1;
 26232                       return make_fixnum (PT);
 26233                     }
 26234                 }
 26235             }
 26236         }
 26237     }
 26238 
 26239  simulate_display:
 26240 
 26241   /* If we wind up here, we failed to move by using the glyphs, so we
 26242      need to simulate display instead.  */
 26243 
 26244   if (b)
 26245     paragraph_dir = Fcurrent_bidi_paragraph_direction (w->contents);
 26246   else
 26247     paragraph_dir = Qleft_to_right;
 26248   if (EQ (paragraph_dir, Qright_to_left))
 26249     dir = -dir;
 26250   if (PT <= BEGV && dir < 0)
 26251     xsignal0 (Qbeginning_of_buffer);
 26252   else if (PT >= ZV && dir > 0)
 26253     xsignal0 (Qend_of_buffer);
 26254   else
 26255     {
 26256       struct text_pos pt;
 26257       struct it it;
 26258       int pt_x, target_x, pixel_width, pt_vpos;
 26259       bool at_eol_p;
 26260       bool overshoot_expected = false;
 26261       bool target_is_eol_p = false;
 26262       void *itdata = bidi_shelve_cache ();
 26263 
 26264       /* Setup the arena.  */
 26265       SET_TEXT_POS (pt, PT, PT_BYTE);
 26266       start_display (&it, w, pt);
 26267       /* When lines are truncated, we could be called with point
 26268          outside of the windows edges, in which case move_it_*
 26269          functions either prematurely stop at window's edge or jump to
 26270          the next screen line, whereas we rely below on our ability to
 26271          reach point, in order to start from its X coordinate.  So we
 26272          need to disregard the window's horizontal extent in that case.  */
 26273       if (it.line_wrap == TRUNCATE)
 26274         it.last_visible_x = DISP_INFINITY;
 26275 
 26276       if (it.cmp_it.id < 0
 26277           && it.method == GET_FROM_STRING
 26278           && it.area == TEXT_AREA
 26279           && it.string_from_display_prop_p
 26280           && (it.sp > 0 && it.stack[it.sp - 1].method == GET_FROM_BUFFER))
 26281         overshoot_expected = true;
 26282 
 26283       /* Find the X coordinate of point.  We start from the beginning
 26284          of this or previous line to make sure we are before point in
 26285          the logical order (since the move_it_* functions can only
 26286          move forward).  */
 26287     reseat:
 26288       reseat_at_previous_visible_line_start (&it);
 26289       it.current_x = it.hpos = it.current_y = it.vpos = 0;
 26290       if (IT_CHARPOS (it) != PT)
 26291         {
 26292           move_it_to (&it, overshoot_expected ? PT - 1 : PT,
 26293                       -1, -1, -1, MOVE_TO_POS);
 26294           /* If we missed point because the character there is
 26295              displayed out of a display vector that has more than one
 26296              glyph, retry expecting overshoot.  */
 26297           if (it.method == GET_FROM_DISPLAY_VECTOR
 26298               && it.current.dpvec_index > 0
 26299               && !overshoot_expected)
 26300             {
 26301               overshoot_expected = true;
 26302               goto reseat;
 26303             }
 26304           else if (IT_CHARPOS (it) != PT && !overshoot_expected)
 26305             move_it_in_display_line (&it, PT, -1, MOVE_TO_POS);
 26306         }
 26307       pt_x = it.current_x;
 26308       pt_vpos = it.vpos;
 26309       if (dir > 0 || overshoot_expected)
 26310         {
 26311           struct glyph_row *row = it.glyph_row;
 26312 
 26313           /* When point is at beginning of line, we don't have
 26314              information about the glyph there loaded into struct
 26315              it.  Calling get_next_display_element fixes that.  */
 26316           if (pt_x == 0)
 26317             get_next_display_element (&it);
 26318           at_eol_p = ITERATOR_AT_END_OF_LINE_P (&it);
 26319           it.glyph_row = NULL;
 26320           PRODUCE_GLYPHS (&it); /* compute it.pixel_width */
 26321           it.glyph_row = row;
 26322           /* PRODUCE_GLYPHS advances it.current_x, so we must restore
 26323              it, lest it will become out of sync with it's buffer
 26324              position.  */
 26325           it.current_x = pt_x;
 26326         }
 26327       else
 26328         at_eol_p = ITERATOR_AT_END_OF_LINE_P (&it);
 26329       pixel_width = it.pixel_width;
 26330       if (overshoot_expected && at_eol_p)
 26331         pixel_width = 0;
 26332       else if (pixel_width <= 0)
 26333         pixel_width = 1;
 26334 
 26335       /* If there's a display string (or something similar) at point,
 26336          we are actually at the glyph to the left of point, so we need
 26337          to correct the X coordinate.  */
 26338       if (overshoot_expected)
 26339         {
 26340           if (it.bidi_p)
 26341             pt_x += pixel_width * it.bidi_it.scan_dir;
 26342           else
 26343             pt_x += pixel_width;
 26344         }
 26345 
 26346       /* Compute target X coordinate, either to the left or to the
 26347          right of point.  On TTY frames, all characters have the same
 26348          pixel width of 1, so we can use that.  On GUI frames we don't
 26349          have an easy way of getting at the pixel width of the
 26350          character to the left of point, so we use a different method
 26351          of getting to that place.  */
 26352       if (dir > 0)
 26353         target_x = pt_x + pixel_width;
 26354       else
 26355         target_x = pt_x - (!FRAME_WINDOW_P (it.f)) * pixel_width;
 26356 
 26357       /* Target X coordinate could be one line above or below the line
 26358          of point, in which case we need to adjust the target X
 26359          coordinate.  Also, if moving to the left, we need to begin at
 26360          the left edge of the point's screen line.  */
 26361       if (dir < 0)
 26362         {
 26363           if (pt_x > 0)
 26364             {
 26365               start_display (&it, w, pt);
 26366               if (it.line_wrap == TRUNCATE)
 26367                 it.last_visible_x = DISP_INFINITY;
 26368               reseat_at_previous_visible_line_start (&it);
 26369               it.current_x = it.current_y = it.hpos = 0;
 26370               if (pt_vpos != 0)
 26371                 move_it_by_lines (&it, pt_vpos);
 26372             }
 26373           else
 26374             {
 26375               move_it_by_lines (&it, -1);
 26376               target_x = it.last_visible_x - !FRAME_WINDOW_P (it.f);
 26377               target_is_eol_p = true;
 26378               /* Under word-wrap, we don't know the x coordinate of
 26379                  the last character displayed on the previous line,
 26380                  which immediately precedes the wrap point.  To find
 26381                  out its x coordinate, we try moving to the right
 26382                  margin of the window, which will stop at the wrap
 26383                  point, and then reset target_x to point at the
 26384                  character that precedes the wrap point.  This is not
 26385                  needed on GUI frames, because (see below) there we
 26386                  move from the left margin one grapheme cluster at a
 26387                  time, and stop when we hit the wrap point.  */
 26388               if (!FRAME_WINDOW_P (it.f) && it.line_wrap == WORD_WRAP)
 26389                 {
 26390                   void *it_data = NULL;
 26391                   struct it it2;
 26392 
 26393                   SAVE_IT (it2, it, it_data);
 26394                   move_it_in_display_line_to (&it, ZV, target_x,
 26395                                               MOVE_TO_POS | MOVE_TO_X);
 26396                   /* If we arrived at target_x, that _is_ the last
 26397                      character on the previous line.  */
 26398                   if (it.current_x != target_x)
 26399                     target_x = it.current_x - 1;
 26400                   RESTORE_IT (&it, &it2, it_data);
 26401                 }
 26402             }
 26403         }
 26404       else
 26405         {
 26406           if (at_eol_p
 26407               || (target_x >= it.last_visible_x
 26408                   && it.line_wrap != TRUNCATE))
 26409             {
 26410               if (pt_x > 0)
 26411                 move_it_by_lines (&it, 0);
 26412               move_it_by_lines (&it, 1);
 26413               target_x = 0;
 26414             }
 26415         }
 26416 
 26417       /* Move to the target X coordinate.  */
 26418       /* On GUI frames, as we don't know the X coordinate of the
 26419          character to the left of point, moving point to the left
 26420          requires walking, one grapheme cluster at a time, until we
 26421          find ourself at a place immediately to the left of the
 26422          character at point.  */
 26423       if (FRAME_WINDOW_P (it.f) && dir < 0)
 26424         {
 26425           struct text_pos new_pos;
 26426           enum move_it_result rc = MOVE_X_REACHED;
 26427 
 26428           if (it.current_x == 0)
 26429             get_next_display_element (&it);
 26430           if (it.what == IT_COMPOSITION)
 26431             {
 26432               new_pos.charpos = it.cmp_it.charpos;
 26433               new_pos.bytepos = -1;
 26434             }
 26435           else
 26436             new_pos = it.current.pos;
 26437 
 26438           while (it.current_x + it.pixel_width <= target_x
 26439                  && (rc == MOVE_X_REACHED
 26440                      /* Under word-wrap, move_it_in_display_line_to
 26441                         stops at correct coordinates, but sometimes
 26442                         returns MOVE_POS_MATCH_OR_ZV.  */
 26443                      || (it.line_wrap == WORD_WRAP
 26444                          && rc == MOVE_POS_MATCH_OR_ZV)))
 26445             {
 26446               int new_x = it.current_x + it.pixel_width;
 26447 
 26448               /* For composed characters, we want the position of the
 26449                  first character in the grapheme cluster (usually, the
 26450                  composition's base character), whereas it.current
 26451                  might give us the position of the _last_ one, e.g. if
 26452                  the composition is rendered in reverse due to bidi
 26453                  reordering.  */
 26454               if (it.what == IT_COMPOSITION)
 26455                 {
 26456                   new_pos.charpos = it.cmp_it.charpos;
 26457                   new_pos.bytepos = -1;
 26458                 }
 26459               else
 26460                 new_pos = it.current.pos;
 26461               if (new_x == it.current_x)
 26462                 new_x++;
 26463               rc = move_it_in_display_line_to (&it, ZV, new_x,
 26464                                                MOVE_TO_POS | MOVE_TO_X);
 26465               if (ITERATOR_AT_END_OF_LINE_P (&it) && !target_is_eol_p)
 26466                 break;
 26467             }
 26468           /* The previous position we saw in the loop is the one we
 26469              want.  */
 26470           if (new_pos.bytepos == -1)
 26471             new_pos.bytepos = CHAR_TO_BYTE (new_pos.charpos);
 26472           it.current.pos = new_pos;
 26473         }
 26474       else if (it.current_x != target_x)
 26475         move_it_in_display_line_to (&it, ZV, target_x, MOVE_TO_POS | MOVE_TO_X);
 26476 
 26477       /* If we ended up in a display string that covers point, move to
 26478          buffer position to the right in the visual order.  */
 26479       if (dir > 0)
 26480         {
 26481           while (IT_CHARPOS (it) == PT)
 26482             {
 26483               set_iterator_to_next (&it, false);
 26484               if (!get_next_display_element (&it))
 26485                 break;
 26486             }
 26487         }
 26488 
 26489       /* Move point to that position.  */
 26490       SET_PT_BOTH (IT_CHARPOS (it), IT_BYTEPOS (it));
 26491       bidi_unshelve_cache (itdata, false);
 26492     }
 26493 
 26494   return make_fixnum (PT);
 26495 
 26496 #undef ROW_GLYPH_NEWLINE_P
 26497 }
 26498 
 26499 DEFUN ("bidi-resolved-levels", Fbidi_resolved_levels,
 26500        Sbidi_resolved_levels, 0, 1, 0,
 26501        doc: /* Return the resolved bidirectional levels of characters at VPOS.
 26502 
 26503 The resolved levels are produced by the Emacs bidi reordering engine
 26504 that implements the UBA, the Unicode Bidirectional Algorithm.  Please
 26505 read the Unicode Standard Annex 9 (UAX#9) for background information
 26506 about these levels.
 26507 
 26508 VPOS is the zero-based number of the current window's screen line
 26509 for which to produce the resolved levels.  If VPOS is nil or omitted,
 26510 it defaults to the screen line of point.  If the window displays a
 26511 header line, VPOS of zero will report on the header line, and first
 26512 line of text in the window will have VPOS of 1.
 26513 
 26514 Value is an array of resolved levels, indexed by glyph number.
 26515 Glyphs are numbered from zero starting from the beginning of the
 26516 screen line, i.e. the left edge of the window for left-to-right lines
 26517 and from the right edge for right-to-left lines.  The resolved levels
 26518 are produced only for the window's text area; text in display margins
 26519 is not included.
 26520 
 26521 If the selected window's display is not up-to-date, or if the specified
 26522 screen line does not display text, this function returns nil.  It is
 26523 highly recommended to bind this function to some simple key, like F8,
 26524 in order to avoid these problems.
 26525 
 26526 This function exists mainly for testing the correctness of the
 26527 Emacs UBA implementation, in particular with the test suite.  */)
 26528   (Lisp_Object vpos)
 26529 {
 26530   struct window *w = XWINDOW (selected_window);
 26531   struct buffer *b = XBUFFER (w->contents);
 26532   int nrow;
 26533   struct glyph_row *row;
 26534 
 26535   if (NILP (vpos))
 26536     {
 26537       int d1, d2, d3, d4, d5;
 26538 
 26539       pos_visible_p (w, PT, &d1, &d2, &d3, &d4, &d5, &nrow);
 26540     }
 26541   else
 26542     {
 26543       CHECK_FIXNUM (vpos);
 26544       nrow = XFIXNUM (vpos);
 26545     }
 26546 
 26547   /* We require up-to-date glyph matrix for this window.  */
 26548   if (w->window_end_valid
 26549       && !windows_or_buffers_changed
 26550       && b
 26551       && !b->clip_changed
 26552       && !b->prevent_redisplay_optimizations_p
 26553       && !window_outdated (w)
 26554       && nrow >= 0
 26555       && nrow < w->current_matrix->nrows
 26556       && (row = MATRIX_ROW (w->current_matrix, nrow))->enabled_p
 26557       && MATRIX_ROW_DISPLAYS_TEXT_P (row))
 26558     {
 26559       struct glyph *g, *e, *g1;
 26560       int nglyphs, i;
 26561       Lisp_Object levels;
 26562 
 26563       if (!row->reversed_p)     /* Left-to-right glyph row.  */
 26564         {
 26565           g = g1 = row->glyphs[TEXT_AREA];
 26566           e = g + row->used[TEXT_AREA];
 26567 
 26568           /* Skip over glyphs at the start of the row that was
 26569              generated by redisplay for its own needs.  */
 26570           while (g < e
 26571                  && NILP (g->object)
 26572                  && g->charpos < 0)
 26573             g++;
 26574           g1 = g;
 26575 
 26576           /* Count the "interesting" glyphs in this row.  */
 26577           for (nglyphs = 0; g < e && !NILP (g->object); g++)
 26578             nglyphs++;
 26579 
 26580           /* Create and fill the array.  */
 26581           levels = make_uninit_vector (nglyphs);
 26582           for (i = 0; g1 < g; i++, g1++)
 26583             ASET (levels, i, make_fixnum (g1->resolved_level));
 26584         }
 26585       else                      /* Right-to-left glyph row.  */
 26586         {
 26587           g = row->glyphs[TEXT_AREA] + row->used[TEXT_AREA] - 1;
 26588           e = row->glyphs[TEXT_AREA] - 1;
 26589           while (g > e
 26590                  && NILP (g->object)
 26591                  && g->charpos < 0)
 26592             g--;
 26593           g1 = g;
 26594           for (nglyphs = 0; g > e && !NILP (g->object); g--)
 26595             nglyphs++;
 26596           levels = make_uninit_vector (nglyphs);
 26597           for (i = 0; g1 > g; i++, g1--)
 26598             ASET (levels, i, make_fixnum (g1->resolved_level));
 26599         }
 26600       return levels;
 26601     }
 26602   else
 26603     return Qnil;
 26604 }
 26605 
 26606 
 26607 
 26608 /***********************************************************************
 26609                                Menu Bar
 26610  ***********************************************************************/
 26611 
 26612 /* Redisplay the menu bar in the frame for window W.
 26613 
 26614    The menu bar of X frames that don't have X toolkit support is
 26615    displayed in a special window W->frame->menu_bar_window.
 26616 
 26617    The menu bar of terminal frames is treated specially as far as
 26618    glyph matrices are concerned.  Menu bar lines are not part of
 26619    windows, so the update is done directly on the frame matrix rows
 26620    for the menu bar.  */
 26621 
 26622 static void
 26623 display_menu_bar (struct window *w)
 26624 {
 26625   struct frame *f = XFRAME (WINDOW_FRAME (w));
 26626   struct it it;
 26627   Lisp_Object items;
 26628   int i;
 26629 
 26630   /* Don't do all this for graphical frames.  */
 26631 #ifdef HAVE_NTGUI
 26632   if (FRAME_W32_P (f))
 26633     return;
 26634 #endif
 26635 #if defined (HAVE_PGTK)
 26636   if (FRAME_PGTK_P (f))
 26637     return;
 26638 #endif
 26639 
 26640 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
 26641   if (FRAME_X_P (f))
 26642     return;
 26643 #endif
 26644 
 26645 #ifdef HAVE_NS
 26646   if (FRAME_NS_P (f))
 26647     return;
 26648 #endif /* HAVE_NS */
 26649 
 26650 #ifdef HAVE_HAIKU
 26651   if (FRAME_HAIKU_P (f))
 26652     return;
 26653 #endif /* HAVE_HAIKU */
 26654 
 26655 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
 26656   eassert (!FRAME_WINDOW_P (f));
 26657   init_iterator (&it, w, -1, -1, f->desired_matrix->rows, MENU_FACE_ID);
 26658   it.first_visible_x = 0;
 26659   it.last_visible_x = FRAME_PIXEL_WIDTH (f);
 26660 #elif defined (HAVE_X_WINDOWS) || defined (HAVE_ANDROID)
 26661   struct window *menu_window = NULL;
 26662   struct face *face = FACE_FROM_ID (f, MENU_FACE_ID);
 26663 
 26664   if (FRAME_WINDOW_P (f))
 26665     {
 26666       /* Menu bar lines are displayed in the desired matrix of the
 26667          dummy window menu_bar_window.  */
 26668       menu_window = XWINDOW (f->menu_bar_window);
 26669       init_iterator (&it, menu_window, -1, -1,
 26670                      menu_window->desired_matrix->rows,
 26671                      MENU_FACE_ID);
 26672     }
 26673   else
 26674 #endif /* not USE_X_TOOLKIT and not USE_GTK */
 26675     {
 26676       /* This is a TTY frame, i.e. character hpos/vpos are used as
 26677          pixel x/y.  */
 26678       init_iterator (&it, w, -1, -1, f->desired_matrix->rows,
 26679                      MENU_FACE_ID);
 26680       it.first_visible_x = 0;
 26681       it.last_visible_x = FRAME_COLS (f);
 26682     }
 26683 
 26684   /* FIXME: This should be controlled by a user option.  See the
 26685      comments in redisplay_tool_bar and display_mode_line about
 26686      this.  */
 26687   it.paragraph_embedding = L2R;
 26688 
 26689   /* Clear all rows of the menu bar.  */
 26690   for (i = 0; i < FRAME_MENU_BAR_LINES (f); ++i)
 26691     {
 26692       struct glyph_row *row = it.glyph_row + i;
 26693       clear_glyph_row (row);
 26694       row->enabled_p = true;
 26695       row->full_width_p = true;
 26696       row->reversed_p = false;
 26697     }
 26698 
 26699   /* Display all items of the menu bar.  */
 26700   items = FRAME_MENU_BAR_ITEMS (it.f);
 26701   for (i = 0; i < ASIZE (items); i += 4)
 26702     {
 26703       Lisp_Object string;
 26704 
 26705       /* Stop at nil string.  */
 26706       string = AREF (items, i + 1);
 26707       if (NILP (string))
 26708         break;
 26709 
 26710       /* Remember where item was displayed.  */
 26711       ASET (items, i + 3, make_fixnum (it.hpos));
 26712 
 26713       /* Display the item, pad with one space.  */
 26714       if (it.current_x < it.last_visible_x)
 26715         display_string (NULL, string, Qnil, 0, 0, &it,
 26716                         SCHARS (string) + 1, 0, 0, STRING_MULTIBYTE (string));
 26717     }
 26718 
 26719   /* Fill out the line with spaces.  */
 26720   if (it.current_x < it.last_visible_x)
 26721     display_string ("", Qnil, Qnil, 0, 0, &it, -1, 0, 0, -1);
 26722 
 26723   /* Compute the total height of the lines.  */
 26724   compute_line_metrics (&it);
 26725   it.glyph_row->full_width_p = true;
 26726   it.glyph_row->continued_p = false;
 26727   it.glyph_row->truncated_on_left_p = false;
 26728   it.glyph_row->truncated_on_right_p = false;
 26729 
 26730   /* This will break the moment someone tries to add another window
 26731      system that uses the no toolkit menu bar.  Oh well.  At least
 26732      there will be an error, meaning he will correct the ifdef inside
 26733      which `face' is defined.  */
 26734 #if defined HAVE_WINDOW_SYSTEM && !defined HAVE_EXT_MENU_BAR
 26735   /* Make a 3D menu bar have a shadow at its right end.  */
 26736   extend_face_to_end_of_line (&it);
 26737   if (face->box != FACE_NO_BOX)
 26738     {
 26739       struct glyph *last = (it.glyph_row->glyphs[TEXT_AREA]
 26740                             + it.glyph_row->used[TEXT_AREA] - 1);
 26741       int box_thickness = face->box_vertical_line_width;
 26742       last->right_box_line_p = true;
 26743       /* Add back the space for the right box line we subtracted in
 26744          init_iterator, since the right_box_line_p flag will make the
 26745          glyph wider.  We actually add only as much space as is
 26746          available for the last glyph of the menu bar and whatever
 26747          space is left beyond it, since that glyph could be only
 26748          partially visible.  */
 26749       if (box_thickness > 0)
 26750         last->pixel_width += max (0, (box_thickness
 26751                                       - (it.current_x - it.last_visible_x)));
 26752     }
 26753 
 26754   /* With the non-toolkit version, modify the menu bar window height
 26755      accordingly.  */
 26756   if (FRAME_WINDOW_P (it.f) && menu_window)
 26757     {
 26758       struct glyph_row *row;
 26759       int delta_height;
 26760 
 26761       row = it.glyph_row;
 26762       delta_height
 26763         = ((row->y + row->height)
 26764            - WINDOW_BOX_HEIGHT_NO_MODE_LINE (menu_window));
 26765 
 26766       if (delta_height != 0)
 26767         {
 26768           FRAME_MENU_BAR_HEIGHT (it.f) += delta_height;
 26769           adjust_frame_size (it.f, -1, -1, 3, false, Qmenu_bar_lines);
 26770         }
 26771     }
 26772 #endif
 26773 }
 26774 
 26775 /* This code is never used on Android where there are only GUI and
 26776    initial frames.  */
 26777 
 26778 #ifndef HAVE_ANDROID
 26779 
 26780 /* Deep copy of a glyph row, including the glyphs.  */
 26781 static void
 26782 deep_copy_glyph_row (struct glyph_row *to, struct glyph_row *from)
 26783 {
 26784   struct glyph *pointers[1 + LAST_AREA];
 26785   int to_used = to->used[TEXT_AREA];
 26786 
 26787   /* Save glyph pointers of TO.  */
 26788   memcpy (pointers, to->glyphs, sizeof to->glyphs);
 26789 
 26790   /* Do a structure assignment.  */
 26791   *to = *from;
 26792 
 26793   /* Restore original glyph pointers of TO.  */
 26794   memcpy (to->glyphs, pointers, sizeof to->glyphs);
 26795 
 26796   /* Copy the glyphs.  */
 26797   memcpy (to->glyphs[TEXT_AREA], from->glyphs[TEXT_AREA],
 26798           min (from->used[TEXT_AREA], to_used) * sizeof (struct glyph));
 26799 
 26800   /* If we filled only part of the TO row, fill the rest with
 26801      space_glyph (which will display as empty space).  */
 26802   if (to_used > from->used[TEXT_AREA])
 26803     fill_up_frame_row_with_spaces (to, to_used);
 26804 }
 26805 
 26806 /* Display one menu item on a TTY, by overwriting the glyphs in the
 26807    frame F's desired glyph matrix with glyphs produced from the menu
 26808    item text.  Called from term.c to display TTY drop-down menus one
 26809    item at a time.
 26810 
 26811    ITEM_TEXT is the menu item text as a C string.
 26812 
 26813    FACE_ID is the face ID to be used for this menu item.  FACE_ID
 26814    could specify one of 3 faces: a face for an enabled item, a face
 26815    for a disabled item, or a face for a selected item.
 26816 
 26817    X and Y are coordinates of the first glyph in the frame's desired
 26818    matrix to be overwritten by the menu item.  Since this is a TTY, Y
 26819    is the zero-based number of the glyph row and X is the zero-based
 26820    glyph number in the row, starting from left, where to start
 26821    displaying the item.
 26822 
 26823    SUBMENU means this menu item drops down a submenu, which
 26824    should be indicated by displaying a proper visual cue after the
 26825    item text.  */
 26826 
 26827 void
 26828 display_tty_menu_item (const char *item_text, int width, int face_id,
 26829                        int x, int y, bool submenu)
 26830 {
 26831   struct it it;
 26832   struct frame *f = SELECTED_FRAME ();
 26833   struct window *w = XWINDOW (f->selected_window);
 26834   struct glyph_row *row;
 26835   size_t item_len = strlen (item_text);
 26836 
 26837   eassert (FRAME_TERMCAP_P (f));
 26838 
 26839   /* Don't write beyond the matrix's last row.  This can happen for
 26840      TTY screens that are not high enough to show the entire menu.
 26841      (This is actually a bit of defensive programming, as
 26842      tty_menu_display already limits the number of menu items to one
 26843      less than the number of screen lines.)  */
 26844   if (y >= f->desired_matrix->nrows)
 26845     return;
 26846 
 26847   init_iterator (&it, w, -1, -1, f->desired_matrix->rows + y, MENU_FACE_ID);
 26848   it.first_visible_x = 0;
 26849   it.last_visible_x = FRAME_COLS (f) - 1;
 26850   row = it.glyph_row;
 26851   /* Start with the row contents from the current matrix.  */
 26852   deep_copy_glyph_row (row, f->current_matrix->rows + y);
 26853   bool saved_width = row->full_width_p;
 26854   row->full_width_p = true;
 26855   bool saved_reversed = row->reversed_p;
 26856   row->reversed_p = false;
 26857   row->enabled_p = true;
 26858 
 26859   /* Arrange for the menu item glyphs to start at (X,Y) and have the
 26860      desired face.  */
 26861   eassert (x < f->desired_matrix->matrix_w);
 26862   it.current_x = it.hpos = x;
 26863   it.current_y = it.vpos = y;
 26864   int saved_used = row->used[TEXT_AREA];
 26865   bool saved_truncated = row->truncated_on_right_p;
 26866   row->used[TEXT_AREA] = x;
 26867   it.face_id = face_id;
 26868   it.line_wrap = TRUNCATE;
 26869 
 26870   /* FIXME: This should be controlled by a user option.  See the
 26871      comments in redisplay_tool_bar and display_mode_line about this.
 26872      Also, if paragraph_embedding could ever be R2L, changes will be
 26873      needed to avoid shifting to the right the row characters in
 26874      term.c:append_glyph.  */
 26875   it.paragraph_embedding = L2R;
 26876 
 26877   /* Pad with a space on the left.  */
 26878   display_string (" ", Qnil, Qnil, 0, 0, &it, 1, 0, FRAME_COLS (f) - 1, -1);
 26879   width--;
 26880   /* Display the menu item, pad with spaces to WIDTH.  */
 26881   if (submenu)
 26882     {
 26883       display_string (item_text, Qnil, Qnil, 0, 0, &it,
 26884                       item_len, 0, FRAME_COLS (f) - 1, -1);
 26885       width -= item_len;
 26886       /* Indicate with " >" that there's a submenu.  */
 26887       display_string (" >", Qnil, Qnil, 0, 0, &it, width, 0,
 26888                       FRAME_COLS (f) - 1, -1);
 26889     }
 26890   else
 26891     display_string (item_text, Qnil, Qnil, 0, 0, &it,
 26892                     width, 0, FRAME_COLS (f) - 1, -1);
 26893 
 26894   row->used[TEXT_AREA] = max (saved_used, row->used[TEXT_AREA]);
 26895   row->truncated_on_right_p = saved_truncated;
 26896   row->hash = row_hash (row);
 26897   row->full_width_p = saved_width;
 26898   row->reversed_p = saved_reversed;
 26899 }
 26900 
 26901 #endif
 26902 
 26903 
 26904 /***********************************************************************
 26905                               Mode Line
 26906  ***********************************************************************/
 26907 
 26908 /* Redisplay mode lines in the window tree whose root is WINDOW.
 26909    If FORCE, redisplay mode lines unconditionally.
 26910    Otherwise, redisplay only mode lines that are garbaged.  Value is
 26911    the number of windows whose mode lines were redisplayed.  */
 26912 
 26913 static int
 26914 redisplay_mode_lines (Lisp_Object window, bool force)
 26915 {
 26916   int nwindows = 0;
 26917 
 26918   while (!NILP (window))
 26919     {
 26920       struct window *w = XWINDOW (window);
 26921 
 26922       if (WINDOWP (w->contents))
 26923         nwindows += redisplay_mode_lines (w->contents, force);
 26924       else if (force
 26925                || FRAME_GARBAGED_P (XFRAME (w->frame))
 26926                || !MATRIX_MODE_LINE_ROW (w->current_matrix)->enabled_p)
 26927         {
 26928           struct text_pos lpoint;
 26929           struct buffer *old = current_buffer;
 26930 
 26931           /* Set the window's buffer for the mode line display.  */
 26932           SET_TEXT_POS (lpoint, PT, PT_BYTE);
 26933           set_buffer_internal_1 (XBUFFER (w->contents));
 26934 
 26935           /* Point refers normally to the selected window.  For any
 26936              other window, set up appropriate value.  */
 26937           if (!EQ (window, selected_window))
 26938             {
 26939               struct text_pos pt;
 26940 
 26941               CLIP_TEXT_POS_FROM_MARKER (pt, w->pointm);
 26942               TEMP_SET_PT_BOTH (CHARPOS (pt), BYTEPOS (pt));
 26943             }
 26944 
 26945           /* Display mode lines.  */
 26946           clear_glyph_matrix (w->desired_matrix);
 26947           if (display_mode_lines (w))
 26948             ++nwindows;
 26949 
 26950           /* Restore old settings.  */
 26951           set_buffer_internal_1 (old);
 26952           TEMP_SET_PT_BOTH (CHARPOS (lpoint), BYTEPOS (lpoint));
 26953         }
 26954 
 26955       window = w->next;
 26956     }
 26957 
 26958   return nwindows;
 26959 }
 26960 
 26961 
 26962 /* Display the mode line, the header line, and the tab-line of window
 26963    W.  Value is the sum number of mode lines, header lines, and tab
 26964    lines actually displayed.  */
 26965 
 26966 static int
 26967 display_mode_lines (struct window *w)
 26968 {
 26969   Lisp_Object old_selected_window = selected_window;
 26970   Lisp_Object new_frame = w->frame;
 26971   specpdl_ref count = SPECPDL_INDEX ();
 26972   int n = 0;
 26973 
 26974   record_unwind_protect (restore_selected_window, selected_window);
 26975   record_unwind_protect
 26976     (restore_frame_selected_window, XFRAME (new_frame)->selected_window);
 26977 
 26978   if (window_wants_mode_line (w))
 26979     {
 26980       Lisp_Object window;
 26981       Lisp_Object default_help
 26982         = buffer_local_value (Qmode_line_default_help_echo, w->contents);
 26983 
 26984       /* Set up mode line help echo.  Do this before selecting w so it
 26985          can reasonably tell whether a mouse click will select w.  */
 26986       XSETWINDOW (window, w);
 26987       if (FUNCTIONP (default_help))
 26988         wset_mode_line_help_echo (w, safe_call1 (default_help, window));
 26989       else if (STRINGP (default_help))
 26990         wset_mode_line_help_echo (w, default_help);
 26991       else
 26992         wset_mode_line_help_echo (w, Qnil);
 26993     }
 26994 
 26995   selected_frame = new_frame;
 26996   /* FIXME: If we were to allow the mode-line's computation changing the buffer
 26997      or window's point, then we'd need select_window_1 here as well.  */
 26998   XSETWINDOW (selected_window, w);
 26999   XFRAME (new_frame)->selected_window = selected_window;
 27000 
 27001   /* These will be set while the mode line specs are processed.  */
 27002   line_number_displayed = false;
 27003   w->column_number_displayed = -1;
 27004 
 27005   if (window_wants_mode_line (w))
 27006     {
 27007       Lisp_Object window_mode_line_format
 27008         = window_parameter (w, Qmode_line_format);
 27009       struct window *sel_w = XWINDOW (old_selected_window);
 27010 
 27011       /* Select mode line face based on the real selected window.  */
 27012       display_mode_line (w,
 27013                          CURRENT_MODE_LINE_ACTIVE_FACE_ID_3 (sel_w, sel_w, w),
 27014                          NILP (window_mode_line_format)
 27015                          ? BVAR (current_buffer, mode_line_format)
 27016                          : window_mode_line_format);
 27017       ++n;
 27018     }
 27019 
 27020   if (window_wants_tab_line (w))
 27021     {
 27022       Lisp_Object window_tab_line_format
 27023         = window_parameter (w, Qtab_line_format);
 27024 
 27025       display_mode_line (w, TAB_LINE_FACE_ID,
 27026                          NILP (window_tab_line_format)
 27027                          ? BVAR (current_buffer, tab_line_format)
 27028                          : window_tab_line_format);
 27029       ++n;
 27030     }
 27031 
 27032   if (window_wants_header_line (w))
 27033     {
 27034       Lisp_Object window_header_line_format
 27035         = window_parameter (w, Qheader_line_format);
 27036 
 27037       display_mode_line (w, HEADER_LINE_FACE_ID,
 27038                          NILP (window_header_line_format)
 27039                          ? BVAR (current_buffer, header_line_format)
 27040                          : window_header_line_format);
 27041       ++n;
 27042     }
 27043 
 27044   unbind_to (count, Qnil);
 27045 
 27046   if (n > 0)
 27047     w->must_be_updated_p = true;
 27048   return n;
 27049 }
 27050 
 27051 
 27052 /* Display mode or header/tab line of window W.  FACE_ID specifies
 27053    which line to display; it is either MODE_LINE_ACTIVE_FACE_ID,
 27054    HEADER_LINE_FACE_ID or TAB_LINE_FACE_ID.  FORMAT is the
 27055    mode/header/tab line format to display.  Value is the pixel height
 27056    of the mode/header/tab line displayed.  */
 27057 
 27058 static int
 27059 display_mode_line (struct window *w, enum face_id face_id, Lisp_Object format)
 27060 {
 27061   struct it it;
 27062   struct face *face;
 27063   specpdl_ref count = SPECPDL_INDEX ();
 27064 
 27065   init_iterator (&it, w, -1, -1, NULL, face_id);
 27066   /* Don't extend on a previously drawn mode-line.
 27067      This may happen if called from pos_visible_p.  */
 27068   it.glyph_row->enabled_p = false;
 27069   prepare_desired_row (w, it.glyph_row, true);
 27070 
 27071   it.glyph_row->mode_line_p = true;
 27072   if (face_id == TAB_LINE_FACE_ID)
 27073     {
 27074       it.glyph_row->tab_line_p = true;
 27075       w->desired_matrix->tab_line_p = true;
 27076     }
 27077   else if (face_id == HEADER_LINE_FACE_ID)
 27078     w->desired_matrix->header_line_p = true;
 27079 
 27080   /* FIXME: This should be controlled by a user option.  But
 27081      supporting such an option is not trivial, since the mode line is
 27082      made up of many separate strings.  */
 27083   it.paragraph_embedding = L2R;
 27084 
 27085   record_unwind_protect (unwind_format_mode_line,
 27086                          format_mode_line_unwind_data (NULL, NULL,
 27087                                                        Qnil, false));
 27088 
 27089   /* Temporarily make frame's keyboard the current kboard so that
 27090      kboard-local variables in the mode_line_format will get the right
 27091      values.  */
 27092   push_kboard (FRAME_KBOARD (it.f));
 27093   record_unwind_save_match_data ();
 27094 
 27095   if (NILP (Vmode_line_compact)
 27096       || face_id == HEADER_LINE_FACE_ID || face_id == TAB_LINE_FACE_ID)
 27097     {
 27098       mode_line_target = MODE_LINE_DISPLAY;
 27099       display_mode_element (&it, 0, 0, 0, format, Qnil, false);
 27100     }
 27101   else
 27102     {
 27103       Lisp_Object mode_string = Fformat_mode_line (format, Qnil, Qnil, Qnil);
 27104       if (EQ (Vmode_line_compact, Qlong)
 27105           && WINDOW_TOTAL_COLS (w) >= SCHARS (mode_string))
 27106         {
 27107           /* The window is wide enough; just display the mode line we
 27108              just computed. */
 27109           display_string (NULL, mode_string, Qnil,
 27110                           0, 0, &it, 0, 0, 0,
 27111                           STRING_MULTIBYTE (mode_string));
 27112         }
 27113       else
 27114         {
 27115           /* Compress the mode line. */
 27116           ptrdiff_t i = 0, i_byte = 0, start = 0;
 27117           int prev = 0;
 27118 
 27119           while (i < SCHARS (mode_string))
 27120             {
 27121               int c = fetch_string_char_advance (mode_string, &i, &i_byte);
 27122               if (c == ' ' && prev == ' ')
 27123                 {
 27124                   display_string (NULL,
 27125                                   Fsubstring (mode_string, make_fixnum (start),
 27126                                               make_fixnum (i - 1)),
 27127                                   Qnil, 0, 0, &it, 0, 0, 0,
 27128                                   STRING_MULTIBYTE (mode_string));
 27129                   /* Skip past the rest of the space characters. */
 27130                   while (c == ' ' && i < SCHARS (mode_string))
 27131                       c = fetch_string_char_advance (mode_string, &i, &i_byte);
 27132                   start = i - 1;
 27133                 }
 27134               prev = c;
 27135             }
 27136 
 27137           /* Display the final bit. */
 27138           if (start < i)
 27139             display_string (NULL,
 27140                             Fsubstring (mode_string, make_fixnum (start),
 27141                                         make_fixnum (i)),
 27142                             Qnil, 0, 0, &it, 0, 0, 0,
 27143                             STRING_MULTIBYTE (mode_string));
 27144         }
 27145     }
 27146   pop_kboard ();
 27147 
 27148   unbind_to (count, Qnil);
 27149 
 27150   /* Fill up with spaces.  */
 27151   display_string (" ", Qnil, Qnil, 0, 0, &it, 10000, -1, -1, 0);
 27152 
 27153   compute_line_metrics (&it);
 27154   it.glyph_row->full_width_p = true;
 27155   it.glyph_row->continued_p = false;
 27156   it.glyph_row->truncated_on_left_p = false;
 27157   it.glyph_row->truncated_on_right_p = false;
 27158 
 27159   /* Make a 3D mode-line have a shadow at its right end.  */
 27160   face = FACE_FROM_ID (it.f, face_id);
 27161   extend_face_to_end_of_line (&it);
 27162   if (face->box != FACE_NO_BOX)
 27163     {
 27164       struct glyph *last = (it.glyph_row->glyphs[TEXT_AREA]
 27165                             + it.glyph_row->used[TEXT_AREA] - 1);
 27166       int box_thickness = face->box_vertical_line_width;
 27167       last->right_box_line_p = true;
 27168       /* Add back the space for the right box line we subtracted in
 27169          init_iterator, since the right_box_line_p flag will make the
 27170          glyph wider.  We actually add only as much space as is
 27171          available for the last glyph of the modeline and whatever
 27172          space is left beyond it, since that glyph could be only
 27173          partially visible */
 27174       if (box_thickness > 0)
 27175         last->pixel_width += max (0, (box_thickness
 27176                                       - (it.current_x - it.last_visible_x)));
 27177     }
 27178 
 27179   return it.glyph_row->height;
 27180 }
 27181 
 27182 /* Move element ELT in LIST to the front of LIST.
 27183    Return the updated list.  */
 27184 
 27185 static Lisp_Object
 27186 move_elt_to_front (Lisp_Object elt, Lisp_Object list)
 27187 {
 27188   register Lisp_Object tail, prev;
 27189   register Lisp_Object tem;
 27190 
 27191   tail = list;
 27192   prev = Qnil;
 27193   while (CONSP (tail))
 27194     {
 27195       tem = XCAR (tail);
 27196 
 27197       if (EQ (elt, tem))
 27198         {
 27199           /* Splice out the link TAIL.  */
 27200           if (NILP (prev))
 27201             list = XCDR (tail);
 27202           else
 27203             Fsetcdr (prev, XCDR (tail));
 27204 
 27205           /* Now make it the first.  */
 27206           Fsetcdr (tail, list);
 27207           return tail;
 27208         }
 27209       else
 27210         prev = tail;
 27211       tail = XCDR (tail);
 27212       maybe_quit ();
 27213     }
 27214 
 27215   /* Not found--return unchanged LIST.  */
 27216   return list;
 27217 }
 27218 
 27219 /* Subroutine to call Fset_text_properties through
 27220    internal_condition_case_n.  ARGS are the arguments of
 27221    Fset_text_properties, in order.  */
 27222 
 27223 static Lisp_Object
 27224 safe_set_text_properties (ptrdiff_t nargs, Lisp_Object *args)
 27225 {
 27226   eassert (nargs == 4);
 27227   return Fset_text_properties (args[0], args[1], args[2], args[3]);
 27228 }
 27229 
 27230 /* Contribute ELT to the mode line for window IT->w.  How it
 27231    translates into text depends on its data type.
 27232 
 27233    IT describes the display environment in which we display, as usual.
 27234 
 27235    DEPTH is the depth in recursion.  It is used to prevent
 27236    infinite recursion here.
 27237 
 27238    FIELD_WIDTH is the number of characters the display of ELT should
 27239    occupy in the mode line, and PRECISION is the maximum number of
 27240    characters to display from ELT's representation.  See
 27241    display_string for details.
 27242 
 27243    Returns the hpos of the end of the text generated by ELT.
 27244 
 27245    PROPS is a property list to add to any string we encounter.
 27246 
 27247    If RISKY, remove (disregard) any properties in any string
 27248    we encounter, and ignore :eval and :propertize.
 27249 
 27250    The global variable `mode_line_target' determines whether the
 27251    output is passed to `store_mode_line_noprop',
 27252    `store_mode_line_string', or `display_string'.  */
 27253 
 27254 static int
 27255 display_mode_element (struct it *it, int depth, int field_width, int precision,
 27256                       Lisp_Object elt, Lisp_Object props, bool risky)
 27257 {
 27258   int n = 0, field, prec;
 27259   bool literal = false;
 27260 
 27261  tail_recurse:
 27262   if (depth > 100)
 27263     elt = build_string ("*too-deep*");
 27264 
 27265   depth++;
 27266 
 27267   switch (XTYPE (elt))
 27268     {
 27269     case Lisp_String:
 27270       {
 27271         /* A string: output it and check for %-constructs within it.  */
 27272         unsigned char c;
 27273         ptrdiff_t offset = 0;
 27274 
 27275         if (SCHARS (elt) > 0
 27276             && (!NILP (props) || risky))
 27277           {
 27278             Lisp_Object oprops, aelt;
 27279             oprops = Ftext_properties_at (make_fixnum (0), elt);
 27280 
 27281             /* If the starting string's properties are not what
 27282                we want, translate the string.  Also, if the string
 27283                is risky, do that anyway.  */
 27284 
 27285             if (NILP (Fequal (props, oprops)) || risky)
 27286               {
 27287                 /* If the starting string has properties,
 27288                    merge the specified ones onto the existing ones.  */
 27289                 if (! NILP (oprops) && !risky)
 27290                   {
 27291                     Lisp_Object tem;
 27292 
 27293                     oprops = Fcopy_sequence (oprops);
 27294                     tem = props;
 27295                     while (CONSP (tem))
 27296                       {
 27297                         oprops = plist_put (oprops, XCAR (tem),
 27298                                             XCAR (XCDR (tem)));
 27299                         tem = XCDR (XCDR (tem));
 27300                       }
 27301                     props = oprops;
 27302                   }
 27303 
 27304                 aelt = Fassoc (elt, mode_line_proptrans_alist, Qnil);
 27305                 if (! NILP (aelt) && !NILP (Fequal (props, XCDR (aelt))))
 27306                   {
 27307                     /* AELT is what we want.  Move it to the front
 27308                        without consing.  */
 27309                     elt = XCAR (aelt);
 27310                     mode_line_proptrans_alist
 27311                       = move_elt_to_front (aelt, mode_line_proptrans_alist);
 27312                   }
 27313                 else
 27314                   {
 27315                     Lisp_Object tem;
 27316 
 27317                     /* If AELT has the wrong props, it is useless.
 27318                        so get rid of it.  */
 27319                     if (! NILP (aelt))
 27320                       mode_line_proptrans_alist
 27321                         = Fdelq (aelt, mode_line_proptrans_alist);
 27322 
 27323                     elt = Fcopy_sequence (elt);
 27324                     /* PROPS might cause set-text-properties to signal
 27325                        an error, so we call it via internal_condition_case_n,
 27326                        to avoid an infloop in redisplay due to the error.  */
 27327                     internal_condition_case_n (safe_set_text_properties,
 27328                                                4,
 27329                                                ((Lisp_Object [])
 27330                                                {make_fixnum (0),
 27331                                                    Flength (elt),
 27332                                                    props,
 27333                                                    elt}),
 27334                                                Qt, safe_eval_handler);
 27335                     /* Add this item to mode_line_proptrans_alist.  */
 27336                     mode_line_proptrans_alist
 27337                       = Fcons (Fcons (elt, props),
 27338                                mode_line_proptrans_alist);
 27339                     /* Truncate mode_line_proptrans_alist
 27340                        to at most 50 elements.  */
 27341                     tem = Fnthcdr (make_fixnum (50),
 27342                                    mode_line_proptrans_alist);
 27343                     if (! NILP (tem))
 27344                       XSETCDR (tem, Qnil);
 27345                   }
 27346               }
 27347           }
 27348 
 27349         offset = 0;
 27350 
 27351         if (literal)
 27352           {
 27353             prec = precision - n;
 27354             switch (mode_line_target)
 27355               {
 27356               case MODE_LINE_NOPROP:
 27357               case MODE_LINE_TITLE:
 27358                 n += store_mode_line_noprop (SSDATA (elt), -1, prec);
 27359                 break;
 27360               case MODE_LINE_STRING:
 27361                 n += store_mode_line_string (NULL, elt, true, 0, prec, Qnil);
 27362                 break;
 27363               case MODE_LINE_DISPLAY:
 27364                 n += display_string (NULL, elt, Qnil, 0, 0, it,
 27365                                      0, prec, 0, STRING_MULTIBYTE (elt));
 27366                 break;
 27367               }
 27368 
 27369             break;
 27370           }
 27371 
 27372         /* Handle the non-literal case.  */
 27373 
 27374         while ((precision <= 0 || n < precision)
 27375                && SREF (elt, offset) != 0
 27376                && (mode_line_target != MODE_LINE_DISPLAY
 27377                    || it->current_x < it->last_visible_x))
 27378           {
 27379             ptrdiff_t last_offset = offset;
 27380 
 27381             /* Advance to end of string or next format specifier.  */
 27382             while ((c = SREF (elt, offset++)) != '\0' && c != '%')
 27383               ;
 27384 
 27385             if (offset - 1 != last_offset)
 27386               {
 27387                 ptrdiff_t nchars, nbytes;
 27388 
 27389                 /* Output to end of string or up to '%'.  Field width
 27390                    is length of string.  Don't output more than
 27391                    PRECISION allows us.  */
 27392                 offset--;
 27393 
 27394                 prec = c_string_width (SDATA (elt) + last_offset,
 27395                                        offset - last_offset, precision - n,
 27396                                        &nchars, &nbytes);
 27397 
 27398                 switch (mode_line_target)
 27399                   {
 27400                   case MODE_LINE_NOPROP:
 27401                   case MODE_LINE_TITLE:
 27402                     n += store_mode_line_noprop (SSDATA (elt) + last_offset, 0, prec);
 27403                     break;
 27404                   case MODE_LINE_STRING:
 27405                     {
 27406                       ptrdiff_t bytepos = last_offset;
 27407                       ptrdiff_t charpos = string_byte_to_char (elt, bytepos);
 27408                       ptrdiff_t endpos = (precision <= 0
 27409                                           ? string_byte_to_char (elt, offset)
 27410                                           : charpos + nchars);
 27411                       Lisp_Object mode_string
 27412                         = Fsubstring (elt, make_fixnum (charpos),
 27413                                       make_fixnum (endpos));
 27414                       n += store_mode_line_string (NULL, mode_string, false,
 27415                                                    0, 0, Qnil);
 27416                     }
 27417                     break;
 27418                   case MODE_LINE_DISPLAY:
 27419                     {
 27420                       ptrdiff_t bytepos = last_offset;
 27421                       ptrdiff_t charpos = string_byte_to_char (elt, bytepos);
 27422 
 27423                       if (precision <= 0)
 27424                         nchars = string_byte_to_char (elt, offset) - charpos;
 27425                       n += display_string (NULL, elt, Qnil, 0, charpos,
 27426                                            it, 0, nchars, 0,
 27427                                            STRING_MULTIBYTE (elt));
 27428                     }
 27429                     break;
 27430                   }
 27431               }
 27432             else /* c == '%' */
 27433               {
 27434                 ptrdiff_t percent_position = offset;
 27435 
 27436                 /* Get the specified minimum width.  Zero means
 27437                    don't pad.  */
 27438                 field = 0;
 27439                 while ((c = SREF (elt, offset++)) >= '0' && c <= '9')
 27440                   field = field * 10 + c - '0';
 27441 
 27442                 /* Don't pad beyond the total padding allowed.  */
 27443                 if (field_width - n > 0 && field > field_width - n)
 27444                   field = field_width - n;
 27445 
 27446                 /* Note that either PRECISION <= 0 or N < PRECISION.  */
 27447                 prec = precision - n;
 27448 
 27449                 if (c == 'M')
 27450                   n += display_mode_element (it, depth, field, prec,
 27451                                              Vglobal_mode_string, props,
 27452                                              risky);
 27453                 else if (c != 0)
 27454                   {
 27455                     bool multibyte;
 27456                     ptrdiff_t bytepos, charpos;
 27457                     const char *spec;
 27458                     Lisp_Object string;
 27459 
 27460                     bytepos = percent_position;
 27461                     charpos = (STRING_MULTIBYTE (elt)
 27462                                ? string_byte_to_char (elt, bytepos)
 27463                                : bytepos);
 27464                     spec = decode_mode_spec (it->w, c, field, &string);
 27465                     eassert (NILP (string) || STRINGP (string));
 27466                     multibyte = !NILP (string) && STRING_MULTIBYTE (string);
 27467                     /* Non-ASCII characters in SPEC should cause mode-line
 27468                        element be displayed as a multibyte string.  */
 27469                     ptrdiff_t nbytes = strlen (spec);
 27470                     ptrdiff_t nchars, mb_nbytes;
 27471                     parse_str_as_multibyte ((const unsigned char *)spec, nbytes,
 27472                                             &nchars, &mb_nbytes);
 27473                     if (!(nbytes == nchars || nbytes != mb_nbytes))
 27474                       multibyte = true;
 27475 
 27476                     switch (mode_line_target)
 27477                       {
 27478                       case MODE_LINE_NOPROP:
 27479                       case MODE_LINE_TITLE:
 27480                         n += store_mode_line_noprop (spec, field, prec);
 27481                         break;
 27482                       case MODE_LINE_STRING:
 27483                         {
 27484                           Lisp_Object tem = build_string (spec);
 27485                           props = Ftext_properties_at (make_fixnum (charpos), elt);
 27486                           /* Should only keep face property in props */
 27487                           n += store_mode_line_string (NULL, tem, false,
 27488                                                        field, prec, props);
 27489                         }
 27490                         break;
 27491                       case MODE_LINE_DISPLAY:
 27492                         {
 27493                           int nglyphs_before, nwritten;
 27494 
 27495                           nglyphs_before = it->glyph_row->used[TEXT_AREA];
 27496                           nwritten = display_string (spec, string, elt,
 27497                                                      charpos, 0, it,
 27498                                                      field, prec, 0,
 27499                                                      multibyte);
 27500 
 27501                           /* Assign to the glyphs written above the
 27502                              string where the `%x' came from, position
 27503                              of the `%'.  */
 27504                           if (nwritten > 0)
 27505                             {
 27506                               struct glyph *glyph
 27507                                 = (it->glyph_row->glyphs[TEXT_AREA]
 27508                                    + nglyphs_before);
 27509                               int i;
 27510 
 27511                               for (i = 0; i < nwritten; ++i)
 27512                                 {
 27513                                   glyph[i].object = elt;
 27514                                   glyph[i].charpos = charpos;
 27515                                 }
 27516 
 27517                               n += nwritten;
 27518                             }
 27519                         }
 27520                         break;
 27521                       }
 27522                   }
 27523                 else /* c == 0 */
 27524                   break;
 27525               }
 27526           }
 27527       }
 27528       break;
 27529 
 27530     case Lisp_Symbol:
 27531       /* A symbol: process the value of the symbol recursively
 27532          as if it appeared here directly.  Avoid error if symbol void.
 27533          Special case: if value of symbol is a string, output the string
 27534          literally.  */
 27535       {
 27536         register Lisp_Object tem;
 27537 
 27538         /* If the variable is not marked as risky to set
 27539            then its contents are risky to use.  */
 27540         if (NILP (Fget (elt, Qrisky_local_variable)))
 27541           risky = true;
 27542 
 27543         tem = Fboundp (elt);
 27544         if (!NILP (tem))
 27545           {
 27546             tem = Fsymbol_value (elt);
 27547             /* If value is a string, output that string literally:
 27548                don't check for % within it.  */
 27549             if (STRINGP (tem))
 27550               literal = true;
 27551 
 27552             if (!EQ (tem, elt))
 27553               {
 27554                 /* Give up right away for nil or t.  */
 27555                 elt = tem;
 27556                 goto tail_recurse;
 27557               }
 27558           }
 27559       }
 27560       break;
 27561 
 27562     case Lisp_Cons:
 27563       {
 27564         register Lisp_Object car, tem;
 27565 
 27566         /* A cons cell: five distinct cases.
 27567            If first element is :eval or :propertize, do something special.
 27568            If first element is a string or a cons, process all the elements
 27569            and effectively concatenate them.
 27570            If first element is a negative number, truncate displaying cdr to
 27571            at most that many characters.  If positive, pad (with spaces)
 27572            to at least that many characters.
 27573            If first element is a symbol, process the cadr or caddr recursively
 27574            according to whether the symbol's value is non-nil or nil.  */
 27575         car = XCAR (elt);
 27576         if (EQ (car, QCeval))
 27577           {
 27578             /* An element of the form (:eval FORM) means evaluate FORM
 27579                and use the result as mode line elements.  */
 27580 
 27581             if (risky)
 27582               break;
 27583 
 27584             if (CONSP (XCDR (elt)))
 27585               {
 27586                 Lisp_Object spec;
 27587                 spec = safe__eval (true, XCAR (XCDR (elt)));
 27588                 /* The :eval form could delete the frame stored in the
 27589                    iterator, which will cause a crash if we try to
 27590                    access faces and other fields (e.g., FRAME_KBOARD)
 27591                    on that frame.  This is a nonsensical thing to do,
 27592                    and signaling an error from redisplay might be
 27593                    dangerous, but we cannot continue with an invalid frame.  */
 27594                 if (!FRAME_LIVE_P (it->f))
 27595                   signal_error (":eval deleted the frame being displayed", elt);
 27596                 n += display_mode_element (it, depth, field_width - n,
 27597                                            precision - n, spec, props,
 27598                                            risky);
 27599               }
 27600           }
 27601         else if (EQ (car, QCpropertize))
 27602           {
 27603             /* An element of the form (:propertize ELT PROPS...)
 27604                means display ELT but applying properties PROPS.  */
 27605 
 27606             if (risky)
 27607               break;
 27608 
 27609             if (CONSP (XCDR (elt)))
 27610               n += display_mode_element (it, depth, field_width - n,
 27611                                          precision - n, XCAR (XCDR (elt)),
 27612                                          XCDR (XCDR (elt)), risky);
 27613           }
 27614         else if (SYMBOLP (car))
 27615           {
 27616             tem = Fboundp (car);
 27617             elt = XCDR (elt);
 27618             if (!CONSP (elt))
 27619               goto invalid;
 27620             /* elt is now the cdr, and we know it is a cons cell.
 27621                Use its car if CAR has a non-nil value.  */
 27622             if (!NILP (tem))
 27623               {
 27624                 tem = Fsymbol_value (car);
 27625                 if (!NILP (tem))
 27626                   {
 27627                     elt = XCAR (elt);
 27628                     goto tail_recurse;
 27629                   }
 27630               }
 27631             /* Symbol's value is nil (or symbol is unbound)
 27632                Get the cddr of the original list
 27633                and if possible find the caddr and use that.  */
 27634             elt = XCDR (elt);
 27635             if (NILP (elt))
 27636               break;
 27637             else if (!CONSP (elt))
 27638               goto invalid;
 27639             elt = XCAR (elt);
 27640             goto tail_recurse;
 27641           }
 27642         else if (FIXNUMP (car))
 27643           {
 27644             register int lim = XFIXNUM (car);
 27645             elt = XCDR (elt);
 27646             if (lim < 0)
 27647               {
 27648                 /* Negative int means reduce maximum width.  */
 27649                 if (precision <= 0)
 27650                   precision = -lim;
 27651                 else
 27652                   precision = min (precision, -lim);
 27653               }
 27654             else if (lim > 0)
 27655               {
 27656                 /* Padding specified.  Don't let it be more than
 27657                    current maximum.  */
 27658                 if (precision > 0)
 27659                   lim = min (precision, lim);
 27660 
 27661                 /* If that's more padding than already wanted, queue it.
 27662                    But don't reduce padding already specified even if
 27663                    that is beyond the current truncation point.  */
 27664                 field_width = max (lim, field_width);
 27665               }
 27666             goto tail_recurse;
 27667           }
 27668         else if (STRINGP (car) || CONSP (car))
 27669           FOR_EACH_TAIL_SAFE (elt)
 27670             {
 27671               if (0 < precision && precision <= n)
 27672                 break;
 27673               n += display_mode_element (it, depth,
 27674                                          /* Pad after only the last
 27675                                             list element.  */
 27676                                          (! CONSP (XCDR (elt))
 27677                                           ? field_width - n
 27678                                           : 0),
 27679                                          precision - n, XCAR (elt),
 27680                                          props, risky);
 27681             }
 27682       }
 27683       break;
 27684 
 27685     default:
 27686     invalid:
 27687       elt = build_string ("*invalid*");
 27688       goto tail_recurse;
 27689     }
 27690 
 27691   /* Pad to FIELD_WIDTH.  */
 27692   if (field_width > 0 && n < field_width)
 27693     {
 27694       switch (mode_line_target)
 27695         {
 27696         case MODE_LINE_NOPROP:
 27697         case MODE_LINE_TITLE:
 27698           n += store_mode_line_noprop ("", field_width - n, 0);
 27699           break;
 27700         case MODE_LINE_STRING:
 27701           n += store_mode_line_string ("", Qnil, false, field_width - n, 0,
 27702                                        Qnil);
 27703           break;
 27704         case MODE_LINE_DISPLAY:
 27705           n += display_string ("", Qnil, Qnil, 0, 0, it, field_width - n,
 27706                                0, 0, 0);
 27707           break;
 27708         }
 27709     }
 27710 
 27711   return n;
 27712 }
 27713 
 27714 /* Store a mode-line string element in mode_line_string_list.
 27715 
 27716    If STRING is non-null, display that C string.  Otherwise, the Lisp
 27717    string LISP_STRING is displayed.
 27718 
 27719    FIELD_WIDTH is the minimum number of output glyphs to produce.
 27720    If STRING has fewer characters than FIELD_WIDTH, pad to the right
 27721    with spaces.  FIELD_WIDTH <= 0 means don't pad.
 27722 
 27723    PRECISION is the maximum number of characters to output from
 27724    STRING.  PRECISION <= 0  means don't truncate the string.
 27725 
 27726    If COPY_STRING, make a copy of LISP_STRING before adding
 27727    properties to the string.
 27728 
 27729    PROPS are the properties to add to the string.
 27730    The mode_line_string_face face property is always added to the string.
 27731  */
 27732 
 27733 static int
 27734 store_mode_line_string (const char *string, Lisp_Object lisp_string,
 27735                         bool copy_string,
 27736                         int field_width, int precision, Lisp_Object props)
 27737 {
 27738   ptrdiff_t len;
 27739   int n = 0;
 27740 
 27741   if (string != NULL)
 27742     {
 27743       len = strnlen (string, precision <= 0 ? SIZE_MAX : precision);
 27744       lisp_string = make_string (string, len);
 27745       if (NILP (props))
 27746         props = mode_line_string_face_prop;
 27747       else if (!NILP (mode_line_string_face))
 27748         {
 27749           Lisp_Object face = plist_get (props, Qface);
 27750           props = Fcopy_sequence (props);
 27751           if (NILP (face))
 27752             face = mode_line_string_face;
 27753           else
 27754             face = list2 (face, mode_line_string_face);
 27755           props = plist_put (props, Qface, face);
 27756         }
 27757       Fadd_text_properties (make_fixnum (0), make_fixnum (len),
 27758                             props, lisp_string);
 27759     }
 27760   else
 27761     {
 27762       len = SCHARS (lisp_string);
 27763       if (precision > 0 && len > precision)
 27764         {
 27765           len = precision;
 27766           lisp_string = Fsubstring (lisp_string, make_fixnum (0), make_fixnum (len));
 27767           precision = -1;
 27768         }
 27769       if (!NILP (mode_line_string_face))
 27770         {
 27771           Lisp_Object face;
 27772           if (NILP (props))
 27773             props = Ftext_properties_at (make_fixnum (0), lisp_string);
 27774           face = plist_get (props, Qface);
 27775           if (NILP (face))
 27776             face = mode_line_string_face;
 27777           else
 27778             face = list2 (face, mode_line_string_face);
 27779           props = list2 (Qface, face);
 27780           if (copy_string)
 27781             lisp_string = Fcopy_sequence (lisp_string);
 27782         }
 27783       if (!NILP (props))
 27784         Fadd_text_properties (make_fixnum (0), make_fixnum (len),
 27785                               props, lisp_string);
 27786     }
 27787 
 27788   if (len > 0)
 27789     {
 27790       mode_line_string_list = Fcons (lisp_string, mode_line_string_list);
 27791       n += len;
 27792     }
 27793 
 27794   if (field_width > len)
 27795     {
 27796       field_width -= len;
 27797       lisp_string = Fmake_string (make_fixnum (field_width), make_fixnum (' '),
 27798                                   Qnil);
 27799       if (!NILP (props))
 27800         Fadd_text_properties (make_fixnum (0), make_fixnum (field_width),
 27801                               props, lisp_string);
 27802       mode_line_string_list = Fcons (lisp_string, mode_line_string_list);
 27803       n += field_width;
 27804     }
 27805 
 27806   return n;
 27807 }
 27808 
 27809 
 27810 DEFUN ("format-mode-line", Fformat_mode_line, Sformat_mode_line,
 27811        1, 4, 0,
 27812        doc: /* Format a string out of a mode line format specification.
 27813 First arg FORMAT specifies the mode line format (see `mode-line-format'
 27814 for details) to use.
 27815 
 27816 By default, the format is evaluated for the currently selected window.
 27817 
 27818 Optional second arg FACE specifies the face property to put on all
 27819 characters for which no face is specified.  The value nil means the
 27820 default face.  The value t means whatever face the window's mode line
 27821 currently uses (either `mode-line' or `mode-line-inactive',
 27822 depending on whether the window is the selected window or not).
 27823 An integer value means the value string has no text
 27824 properties.
 27825 
 27826 Optional third and fourth args WINDOW and BUFFER specify the window
 27827 and buffer to use as the context for the formatting (defaults
 27828 are the selected window and the WINDOW's buffer).  */)
 27829      (Lisp_Object format, Lisp_Object face,
 27830       Lisp_Object window, Lisp_Object buffer)
 27831 {
 27832   struct it it;
 27833   int len;
 27834   struct window *w;
 27835   struct buffer *old_buffer = NULL;
 27836   int face_id;
 27837   bool no_props = FIXNUMP (face);
 27838   specpdl_ref count = SPECPDL_INDEX ();
 27839   Lisp_Object str;
 27840   int string_start = 0;
 27841 
 27842   w = decode_any_window (window);
 27843   XSETWINDOW (window, w);
 27844 
 27845   if (NILP (buffer))
 27846     buffer = w->contents;
 27847   CHECK_BUFFER (buffer);
 27848 
 27849   /* Make formatting the modeline a non-op when noninteractive, otherwise
 27850      there will be problems later caused by a partially initialized frame.  */
 27851   if (NILP (format) || noninteractive)
 27852     return empty_unibyte_string;
 27853 
 27854   if (no_props)
 27855     face = Qnil;
 27856 
 27857   face_id = (NILP (face) || EQ (face, Qdefault)) ? DEFAULT_FACE_ID
 27858     : EQ (face, Qt) ? (EQ (window, selected_window)
 27859                        ? MODE_LINE_ACTIVE_FACE_ID : MODE_LINE_INACTIVE_FACE_ID)
 27860     : EQ (face, Qmode_line_active) ? MODE_LINE_ACTIVE_FACE_ID
 27861     : EQ (face, Qmode_line_inactive) ? MODE_LINE_INACTIVE_FACE_ID
 27862     : EQ (face, Qheader_line) ? HEADER_LINE_FACE_ID
 27863     : EQ (face, Qtab_line) ? TAB_LINE_FACE_ID
 27864     : EQ (face, Qtab_bar) ? TAB_BAR_FACE_ID
 27865     : EQ (face, Qtool_bar) ? TOOL_BAR_FACE_ID
 27866     : DEFAULT_FACE_ID;
 27867 
 27868   old_buffer = current_buffer;
 27869 
 27870   /* Save things including mode_line_proptrans_alist,
 27871      and set that to nil so that we don't alter the outer value.  */
 27872   record_unwind_protect (unwind_format_mode_line,
 27873                          format_mode_line_unwind_data
 27874                            (XFRAME (WINDOW_FRAME (w)),
 27875                             old_buffer, selected_window, true));
 27876   mode_line_proptrans_alist = Qnil;
 27877 
 27878   Fselect_window (window, Qt);
 27879   set_buffer_internal_1 (XBUFFER (buffer));
 27880 
 27881   init_iterator (&it, w, -1, -1, NULL, face_id);
 27882 
 27883   if (no_props)
 27884     {
 27885       mode_line_target = MODE_LINE_NOPROP;
 27886       mode_line_string_face_prop = Qnil;
 27887       mode_line_string_list = Qnil;
 27888       string_start = MODE_LINE_NOPROP_LEN (0);
 27889     }
 27890   else
 27891     {
 27892       mode_line_target = MODE_LINE_STRING;
 27893       mode_line_string_list = Qnil;
 27894       mode_line_string_face = face;
 27895       mode_line_string_face_prop
 27896         = NILP (face) ? Qnil : list2 (Qface, face);
 27897     }
 27898 
 27899   push_kboard (FRAME_KBOARD (it.f));
 27900   display_mode_element (&it, 0, 0, 0, format, Qnil, false);
 27901   pop_kboard ();
 27902 
 27903   if (no_props)
 27904     {
 27905       len = MODE_LINE_NOPROP_LEN (string_start);
 27906       str = make_string (mode_line_noprop_buf + string_start, len);
 27907     }
 27908   else
 27909     {
 27910       mode_line_string_list = Fnreverse (mode_line_string_list);
 27911       str = Fmapconcat (Qidentity, mode_line_string_list,
 27912                         empty_unibyte_string);
 27913     }
 27914 
 27915   return unbind_to (count, str);
 27916 }
 27917 
 27918 /* Write a null-terminated, right justified decimal representation of
 27919    the positive integer D to BUF using a minimal field width WIDTH.  */
 27920 
 27921 static void
 27922 pint2str (register char *buf, register int width, register ptrdiff_t d)
 27923 {
 27924   register char *p = buf;
 27925 
 27926   if (d <= 0)
 27927     *p++ = '0';
 27928   else
 27929     {
 27930       while (d > 0)
 27931         {
 27932           *p++ = d % 10 + '0';
 27933           d /= 10;
 27934         }
 27935     }
 27936 
 27937   for (width -= (int) (p - buf); width > 0; --width)
 27938     *p++ = ' ';
 27939   *p-- = '\0';
 27940   while (p > buf)
 27941     {
 27942       d = *buf;
 27943       *buf++ = *p;
 27944       *p-- = d;
 27945     }
 27946 }
 27947 
 27948 /* Write a null-terminated, right justified decimal and "human
 27949    readable" representation of the nonnegative integer D to BUF using
 27950    a minimal field width WIDTH.  D should be smaller than 999.5e24. */
 27951 
 27952 static const char power_letter[] =
 27953   {
 27954     0,   /* no letter */
 27955     'k', /* kilo */
 27956     'M', /* mega */
 27957     'G', /* giga */
 27958     'T', /* tera */
 27959     'P', /* peta */
 27960     'E', /* exa */
 27961     'Z', /* zetta */
 27962     'Y', /* yotta */
 27963     'R', /* ronna */
 27964     'Q'  /* quetta */
 27965   };
 27966 
 27967 static void
 27968 pint2hrstr (char *buf, int width, ptrdiff_t d)
 27969 {
 27970   /* We aim to represent the nonnegative integer D as
 27971      QUOTIENT.TENTHS * 10 ^ (3 * EXPONENT). */
 27972   ptrdiff_t quotient = d;
 27973   int remainder = 0;
 27974   /* -1 means: do not use TENTHS. */
 27975   int tenths = -1;
 27976   int exponent = 0;
 27977 
 27978   /* Length of QUOTIENT.TENTHS as a string. */
 27979   int length;
 27980 
 27981   char * psuffix;
 27982   char * p;
 27983 
 27984   if (quotient >= 1000)
 27985     {
 27986       /* Scale to the appropriate EXPONENT. */
 27987       do
 27988         {
 27989           remainder = quotient % 1000;
 27990           quotient /= 1000;
 27991           exponent++;
 27992         }
 27993       while (quotient >= 1000);
 27994 
 27995       /* Round to nearest and decide whether to use TENTHS or not. */
 27996       if (quotient <= 9)
 27997         {
 27998           tenths = remainder / 100;
 27999           if (remainder % 100 >= 50)
 28000             {
 28001               if (tenths < 9)
 28002                 tenths++;
 28003               else
 28004                 {
 28005                   quotient++;
 28006                   if (quotient == 10)
 28007                     tenths = -1;
 28008                   else
 28009                     tenths = 0;
 28010                 }
 28011             }
 28012         }
 28013       else
 28014         if (remainder >= 500)
 28015           {
 28016             if (quotient < 999)
 28017               quotient++;
 28018             else
 28019               {
 28020                 quotient = 1;
 28021                 exponent++;
 28022                 tenths = 0;
 28023               }
 28024           }
 28025     }
 28026 
 28027   /* Calculate the LENGTH of QUOTIENT.TENTHS as a string. */
 28028   if (tenths == -1 && quotient <= 99)
 28029     if (quotient <= 9)
 28030       length = 1;
 28031     else
 28032       length = 2;
 28033   else
 28034     length = 3;
 28035   p = psuffix = buf + max (width, length);
 28036 
 28037   /* Print EXPONENT. */
 28038   *psuffix++ = power_letter[exponent];
 28039   *psuffix = '\0';
 28040 
 28041   /* Print TENTHS. */
 28042   if (tenths >= 0)
 28043     {
 28044       *--p = '0' + tenths;
 28045       *--p = '.';
 28046     }
 28047 
 28048   /* Print QUOTIENT. */
 28049   do
 28050     {
 28051       int digit = quotient % 10;
 28052       *--p =  '0' + digit;
 28053     }
 28054   while ((quotient /= 10) != 0);
 28055 
 28056   /* Print leading spaces. */
 28057   while (buf < p)
 28058     *--p = ' ';
 28059 }
 28060 
 28061 /* Set a mnemonic character for coding_system (Lisp symbol) in BUF.
 28062    If EOL_FLAG, set also a mnemonic character for end-of-line
 28063    type of CODING_SYSTEM.  Return updated pointer into BUF.  */
 28064 
 28065 static unsigned char invalid_eol_type[] = "(*invalid*)";
 28066 
 28067 static char *
 28068 decode_mode_spec_coding (Lisp_Object coding_system, char *buf, bool eol_flag)
 28069 {
 28070   Lisp_Object val;
 28071   bool multibyte = !NILP (BVAR (current_buffer, enable_multibyte_characters));
 28072   const unsigned char *eol_str;
 28073   int eol_str_len;
 28074   /* The EOL conversion we are using.  */
 28075   Lisp_Object eoltype;
 28076 
 28077   val = CODING_SYSTEM_SPEC (coding_system);
 28078   eoltype = Qnil;
 28079 
 28080   if (!VECTORP (val))           /* Not yet decided.  */
 28081     {
 28082       *buf++ = multibyte ? '-' : ' ';
 28083       if (eol_flag)
 28084         eoltype = eol_mnemonic_undecided;
 28085       /* Don't mention EOL conversion if it isn't decided.  */
 28086     }
 28087   else
 28088     {
 28089       Lisp_Object attrs;
 28090       Lisp_Object eolvalue;
 28091 
 28092       attrs = AREF (val, 0);
 28093       eolvalue = AREF (val, 2);
 28094 
 28095       if (multibyte)
 28096         buf += CHAR_STRING (XFIXNAT (CODING_ATTR_MNEMONIC (attrs)),
 28097                             (unsigned char *) buf);
 28098       else
 28099         *buf++ = ' ';
 28100 
 28101       if (eol_flag)
 28102         {
 28103           /* The EOL conversion that is normal on this system.  */
 28104 
 28105           if (NILP (eolvalue))  /* Not yet decided.  */
 28106             eoltype = eol_mnemonic_undecided;
 28107           else if (VECTORP (eolvalue)) /* Not yet decided.  */
 28108             eoltype = eol_mnemonic_undecided;
 28109           else                  /* eolvalue is Qunix, Qdos, or Qmac.  */
 28110             eoltype = (EQ (eolvalue, Qunix)
 28111                        ? eol_mnemonic_unix
 28112                        : EQ (eolvalue, Qdos)
 28113                        ? eol_mnemonic_dos : eol_mnemonic_mac);
 28114         }
 28115     }
 28116 
 28117   if (eol_flag)
 28118     {
 28119       /* Mention the EOL conversion if it is not the usual one.  */
 28120       if (STRINGP (eoltype))
 28121         {
 28122           eol_str = SDATA (eoltype);
 28123           eol_str_len = SBYTES (eoltype);
 28124         }
 28125       else if (CHARACTERP (eoltype))
 28126         {
 28127           int c = XFIXNAT (eoltype);
 28128           return buf + CHAR_STRING (c, (unsigned char *) buf);
 28129         }
 28130       else
 28131         {
 28132           eol_str = invalid_eol_type;
 28133           eol_str_len = sizeof (invalid_eol_type) - 1;
 28134         }
 28135       memcpy (buf, eol_str, eol_str_len);
 28136       buf += eol_str_len;
 28137     }
 28138 
 28139   return buf;
 28140 }
 28141 
 28142 /* Return the approximate percentage N is of D (rounding upward), or 99,
 28143    whichever is less.  Assume 0 < D and 0 <= N <= D * INT_MAX / 100.  */
 28144 
 28145 static int
 28146 percent99 (ptrdiff_t n, ptrdiff_t d)
 28147 {
 28148   int percent = (d - 1 + 100.0 * n) / d;
 28149   return min (percent, 99);
 28150 }
 28151 
 28152 /* Return a string for the output of a mode line %-spec for window W,
 28153    generated by character C.  FIELD_WIDTH > 0 means pad the string
 28154    returned with spaces to that value.  Set *STRING to be a Lisp
 28155    string if the resulting string is taken from that Lisp string;
 28156    otherwise, set *STRING to Qnil.
 28157 
 28158    Note we operate on the current buffer for most purposes.  */
 28159 
 28160 static char lots_of_dashes[] = "--------------------------------------------------------------------------------------------------------------------------------------------";
 28161 
 28162 static const char *
 28163 decode_mode_spec (struct window *w, register int c, int field_width,
 28164                   Lisp_Object *string)
 28165 {
 28166   Lisp_Object obj;
 28167   struct frame *f = XFRAME (WINDOW_FRAME (w));
 28168   char *decode_mode_spec_buf = f->decode_mode_spec_buffer;
 28169   /* We are going to use f->decode_mode_spec_buffer as the buffer to
 28170      produce strings from numerical values, so limit preposterously
 28171      large values of FIELD_WIDTH to avoid overrunning the buffer's
 28172      end.  The size of the buffer is enough for FRAME_MESSAGE_BUF_SIZE
 28173      bytes plus the terminating null.  */
 28174   int width = min (field_width, FRAME_MESSAGE_BUF_SIZE (f));
 28175   struct buffer *b = current_buffer;
 28176 
 28177   obj = Qnil;
 28178   *string = Qnil;
 28179 
 28180   switch (c)
 28181     {
 28182     case '*':
 28183       if (!NILP (BVAR (b, read_only)))
 28184         return "%";
 28185       if (BUF_MODIFF (b) > BUF_SAVE_MODIFF (b))
 28186         return "*";
 28187       return "-";
 28188 
 28189     case '+':
 28190       /* This differs from %* only for a modified read-only buffer.  */
 28191       if (BUF_MODIFF (b) > BUF_SAVE_MODIFF (b))
 28192         return "*";
 28193       if (!NILP (BVAR (b, read_only)))
 28194         return "%";
 28195       return "-";
 28196 
 28197     case '&':
 28198       /* This differs from %* in ignoring read-only-ness.  */
 28199       if (BUF_MODIFF (b) > BUF_SAVE_MODIFF (b))
 28200         return "*";
 28201       return "-";
 28202 
 28203     case '%':
 28204       return "%";
 28205 
 28206     case '[':
 28207       {
 28208         int i;
 28209         char *p;
 28210 
 28211         if (command_loop_level > 5)
 28212           return "[[[... ";
 28213         p = decode_mode_spec_buf;
 28214         for (i = 0; i < command_loop_level; i++)
 28215           *p++ = '[';
 28216         *p = 0;
 28217         return decode_mode_spec_buf;
 28218       }
 28219 
 28220     case ']':
 28221       {
 28222         int i;
 28223         char *p;
 28224 
 28225         if (command_loop_level > 5)
 28226           return " ...]]]";
 28227         p = decode_mode_spec_buf;
 28228         for (i = 0; i < command_loop_level; i++)
 28229           *p++ = ']';
 28230         *p = 0;
 28231         return decode_mode_spec_buf;
 28232       }
 28233 
 28234     case '-':
 28235       {
 28236         register int i;
 28237 
 28238         /* Let lots_of_dashes be a string of infinite length.  */
 28239         if (mode_line_target == MODE_LINE_NOPROP
 28240             || mode_line_target == MODE_LINE_STRING)
 28241           return "--";
 28242         if (field_width <= 0
 28243             || field_width > sizeof (lots_of_dashes))
 28244           {
 28245             for (i = 0; i < FRAME_MESSAGE_BUF_SIZE (f) - 1; ++i)
 28246               decode_mode_spec_buf[i] = '-';
 28247             decode_mode_spec_buf[i] = '\0';
 28248             return decode_mode_spec_buf;
 28249           }
 28250         else
 28251           return lots_of_dashes;
 28252       }
 28253 
 28254     case 'b':
 28255       obj = BVAR (b, name);
 28256       break;
 28257 
 28258     case 'c':
 28259     case 'C':
 28260       /* %c, %C, and %l are ignored in `frame-title-format'.
 28261          (In redisplay_internal, the frame title is drawn _before_ the
 28262          windows are updated, so the stuff which depends on actual
 28263          window contents (such as %l) may fail to render properly, or
 28264          even crash emacs.)  */
 28265       if (mode_line_target == MODE_LINE_TITLE)
 28266         return "";
 28267       else
 28268         {
 28269           ptrdiff_t col = current_column ();
 28270           int disp_col = (c == 'C') ? col + 1 : col;
 28271           w->column_number_displayed = col;
 28272           pint2str (decode_mode_spec_buf, width, disp_col);
 28273           return decode_mode_spec_buf;
 28274         }
 28275 
 28276     case 'e':
 28277 #if !defined SYSTEM_MALLOC && !defined HYBRID_MALLOC
 28278       {
 28279         if (NILP (Vmemory_full))
 28280           return "";
 28281         else
 28282           return "!MEM FULL! ";
 28283       }
 28284 #else
 28285       return "";
 28286 #endif
 28287 
 28288     case 'F':
 28289       /* %F displays the frame name.  */
 28290       if (!NILP (f->title))
 28291         return SSDATA (f->title);
 28292       if (f->explicit_name || ! FRAME_WINDOW_P (f))
 28293         return SSDATA (f->name);
 28294       return "Emacs";
 28295 
 28296     case 'f':
 28297       obj = BVAR (b, filename);
 28298       break;
 28299 
 28300     case 'i':
 28301       {
 28302         ptrdiff_t size = ZV - BEGV;
 28303         pint2str (decode_mode_spec_buf, width, size);
 28304         return decode_mode_spec_buf;
 28305       }
 28306 
 28307     case 'I':
 28308       {
 28309         ptrdiff_t size = ZV - BEGV;
 28310         pint2hrstr (decode_mode_spec_buf, width, size);
 28311         return decode_mode_spec_buf;
 28312       }
 28313 
 28314     case 'l':
 28315       {
 28316         ptrdiff_t startpos, startpos_byte, line, linepos, linepos_byte;
 28317         ptrdiff_t topline, nlines, height;
 28318         ptrdiff_t junk;
 28319 
 28320         /* %c, %C, and %l are ignored in `frame-title-format'.  */
 28321         if (mode_line_target == MODE_LINE_TITLE)
 28322           return "";
 28323 
 28324         startpos = marker_position (w->start);
 28325         startpos_byte = marker_byte_position (w->start);
 28326         height = WINDOW_TOTAL_LINES (w);
 28327         /* We cannot cope with w->start being outside of the
 28328            accessible portion of the buffer; in particular,
 28329            display_count_lines call below might infloop if called with
 28330            startpos_byte outside of the [BEGV_BYTE..ZV_BYTE] region.
 28331            Such w->start means we were called in some "creative" way
 28332            when the buffer's restriction was changed, but the window
 28333            wasn't yet redisplayed after that.  If that happens, we
 28334            need to determine a new base line.  */
 28335         if (!(BUF_BEGV_BYTE (b) <= startpos_byte
 28336               && startpos_byte <= BUF_ZV_BYTE (b)))
 28337           {
 28338             startpos = BUF_BEGV (b);
 28339             startpos_byte = BUF_BEGV_BYTE (b);
 28340             w->base_line_pos = 0;
 28341             w->base_line_number = 0;
 28342           }
 28343 
 28344         /* If we decided that this buffer isn't suitable for line numbers,
 28345            don't forget that too fast.  */
 28346         if (w->base_line_pos == -1)
 28347           goto no_value;
 28348 
 28349         /* If the buffer is very big, don't waste time.  */
 28350         if (FIXNUMP (Vline_number_display_limit)
 28351             && BUF_ZV (b) - BUF_BEGV (b) > XFIXNUM (Vline_number_display_limit))
 28352           {
 28353             w->base_line_pos = 0;
 28354             w->base_line_number = 0;
 28355             goto no_value;
 28356           }
 28357 
 28358         if (w->base_line_number > 0
 28359             && w->base_line_pos > 0
 28360             && w->base_line_pos <= startpos)
 28361           {
 28362             line = w->base_line_number;
 28363             linepos = w->base_line_pos;
 28364             linepos_byte = buf_charpos_to_bytepos (b, linepos);
 28365           }
 28366         else
 28367           {
 28368             line = 1;
 28369             linepos = BUF_BEGV (b);
 28370             linepos_byte = BUF_BEGV_BYTE (b);
 28371           }
 28372 
 28373         /* Count lines from base line to window start position.  */
 28374         nlines = display_count_lines (linepos_byte,
 28375                                       startpos_byte,
 28376                                       startpos, &junk);
 28377 
 28378         topline = nlines + line;
 28379 
 28380         /* Determine a new base line, if the old one is too close
 28381            or too far away, or if we did not have one.
 28382            "Too close" means it's plausible a scroll-down would
 28383            go back past it.  */
 28384         if (startpos == BUF_BEGV (b))
 28385           {
 28386             w->base_line_number = topline;
 28387             w->base_line_pos = BUF_BEGV (b);
 28388           }
 28389         else if (nlines < height + 25 || nlines > height * 3 + 50
 28390                  || linepos == BUF_BEGV (b))
 28391           {
 28392             ptrdiff_t limit = BUF_BEGV (b);
 28393             ptrdiff_t limit_byte = BUF_BEGV_BYTE (b);
 28394             ptrdiff_t position;
 28395             ptrdiff_t distance
 28396               = (line_number_display_limit_width < 0 ? 0
 28397                  : ckd_mul (&distance, line_number_display_limit_width,
 28398                             height * 2 + 30)
 28399                  ? PTRDIFF_MAX : distance);
 28400 
 28401             if (startpos - distance > limit)
 28402               {
 28403                 limit = startpos - distance;
 28404                 limit_byte = CHAR_TO_BYTE (limit);
 28405               }
 28406 
 28407             nlines = display_count_lines (startpos_byte,
 28408                                           limit_byte,
 28409                                           - (height * 2 + 30),
 28410                                           &position);
 28411             /* If we couldn't find the lines we wanted within
 28412                line_number_display_limit_width chars per line,
 28413                give up on line numbers for this window.  */
 28414             if (position == limit_byte && limit == startpos - distance)
 28415               {
 28416                 w->base_line_pos = -1;
 28417                 w->base_line_number = 0;
 28418                 goto no_value;
 28419               }
 28420 
 28421             w->base_line_number = topline - nlines;
 28422             w->base_line_pos = BYTE_TO_CHAR (position);
 28423           }
 28424 
 28425         /* Now count lines from the start pos to point.  */
 28426         nlines = display_count_lines (startpos_byte,
 28427                                       PT_BYTE, PT, &junk);
 28428 
 28429         /* Record that we did display the line number.  */
 28430         line_number_displayed = true;
 28431 
 28432         /* Make the string to show.  */
 28433         pint2str (decode_mode_spec_buf, width, topline + nlines);
 28434         return decode_mode_spec_buf;
 28435     no_value:
 28436         {
 28437           char *p = decode_mode_spec_buf;
 28438           int pad = width - 2;
 28439           while (pad-- > 0)
 28440             *p++ = ' ';
 28441           *p++ = '?';
 28442           *p++ = '?';
 28443           *p = '\0';
 28444           return decode_mode_spec_buf;
 28445         }
 28446       }
 28447       break;
 28448 
 28449     case 'm':
 28450       obj = BVAR (b, mode_name);
 28451       break;
 28452 
 28453     case 'n':
 28454       if (BUF_BEGV (b) > BUF_BEG (b) || BUF_ZV (b) < BUF_Z (b))
 28455         return " Narrow";
 28456       break;
 28457 
 28458       /* Display the "degree of travel" of the window through the buffer.  */
 28459     case 'o':
 28460       {
 28461         ptrdiff_t toppos = marker_position (w->start);
 28462         ptrdiff_t botpos = BUF_Z (b) - w->window_end_pos;
 28463         ptrdiff_t begv = BUF_BEGV (b);
 28464         ptrdiff_t zv = BUF_ZV (b);
 28465 
 28466         if (zv <= botpos)
 28467           return toppos <= begv ? "All" : "Bottom";
 28468         else if (toppos <= begv)
 28469           return "Top";
 28470         else
 28471           {
 28472           sprintf (decode_mode_spec_buf, "%2d%%",
 28473                    percent99 (toppos - begv, (toppos - begv) + (zv - botpos)));
 28474           return decode_mode_spec_buf;
 28475           }
 28476       }
 28477 
 28478       /* Display percentage of buffer above the top of the screen.  */
 28479     case 'p':
 28480       {
 28481         ptrdiff_t pos = marker_position (w->start);
 28482         ptrdiff_t begv = BUF_BEGV (b);
 28483         ptrdiff_t zv = BUF_ZV (b);
 28484 
 28485         if (w->window_end_pos <= BUF_Z (b) - zv)
 28486           return pos <= begv ? "All" : "Bottom";
 28487         else if (pos <= begv)
 28488           return "Top";
 28489         else
 28490           {
 28491             sprintf (decode_mode_spec_buf, "%2d%%",
 28492                      percent99 (pos - begv, zv - begv));
 28493             return decode_mode_spec_buf;
 28494           }
 28495       }
 28496 
 28497       /* Display percentage of size above the bottom of the screen.  */
 28498     case 'P':
 28499       {
 28500         ptrdiff_t toppos = marker_position (w->start);
 28501         ptrdiff_t botpos = BUF_Z (b) - w->window_end_pos;
 28502         ptrdiff_t begv = BUF_BEGV (b);
 28503         ptrdiff_t zv = BUF_ZV (b);
 28504 
 28505         if (zv <= botpos)
 28506           return toppos <= begv ? "All" : "Bottom";
 28507         else
 28508           {
 28509             sprintf (decode_mode_spec_buf,
 28510                      &"Top%2d%%"[begv < toppos ? sizeof "Top" - 1 : 0],
 28511                      percent99 (botpos - begv, zv - begv));
 28512             return decode_mode_spec_buf;
 28513           }
 28514       }
 28515 
 28516       /* Display percentage offsets of top and bottom of the window,
 28517          using "All" (but not "Top" or "Bottom") where appropriate.  */
 28518     case 'q':
 28519       {
 28520         ptrdiff_t toppos = marker_position (w->start);
 28521         ptrdiff_t botpos = BUF_Z (b) - w->window_end_pos;
 28522         ptrdiff_t begv = BUF_BEGV (b);
 28523         ptrdiff_t zv = BUF_ZV (b);
 28524         int top_perc, bot_perc;
 28525 
 28526         if ((toppos <= begv) && (zv <= botpos))
 28527           return "All   ";
 28528 
 28529         top_perc = toppos <= begv ? 0 : percent99 (toppos - begv, zv - begv);
 28530         bot_perc = zv <= botpos ? 100 : percent99 (botpos - begv, zv - begv);
 28531 
 28532         if (top_perc == bot_perc)
 28533           sprintf (decode_mode_spec_buf, "%d%%", top_perc);
 28534         else
 28535           sprintf (decode_mode_spec_buf, "%d-%d%%", top_perc, bot_perc);
 28536 
 28537         return decode_mode_spec_buf;
 28538       }
 28539 
 28540     case 's':
 28541       /* status of process */
 28542       obj = Fget_buffer_process (Fcurrent_buffer ());
 28543       if (NILP (obj))
 28544         return "no process";
 28545 #ifndef MSDOS
 28546       obj = Fsymbol_name (Fprocess_status (obj));
 28547 #endif
 28548       break;
 28549 
 28550     case '@':
 28551       {
 28552         specpdl_ref count = inhibit_garbage_collection ();
 28553         Lisp_Object curdir = BVAR (current_buffer, directory);
 28554         Lisp_Object val = Qnil;
 28555 
 28556         if (STRINGP (curdir))
 28557           val = safe_call1 (intern ("file-remote-p"), curdir);
 28558 
 28559         val = unbind_to (count, val);
 28560 
 28561         if (NILP (val))
 28562           return "-";
 28563         else
 28564           return "@";
 28565       }
 28566 
 28567     case 'z':
 28568       /* coding-system (not including end-of-line format) */
 28569     case 'Z':
 28570       /* coding-system (including end-of-line type) */
 28571       {
 28572         bool eol_flag = (c == 'Z');
 28573         char *p = decode_mode_spec_buf;
 28574 
 28575         if (! FRAME_WINDOW_P (f))
 28576           {
 28577             /* No need to mention EOL here--the terminal never needs
 28578                to do EOL conversion.  */
 28579             p = decode_mode_spec_coding (CODING_ID_NAME
 28580                                          (FRAME_KEYBOARD_CODING (f)->id),
 28581                                          p, false);
 28582             p = decode_mode_spec_coding (CODING_ID_NAME
 28583                                          (FRAME_TERMINAL_CODING (f)->id),
 28584                                          p, false);
 28585           }
 28586         p = decode_mode_spec_coding (BVAR (b, buffer_file_coding_system),
 28587                                      p, eol_flag);
 28588 
 28589 #if false /* This proves to be annoying; I think we can do without. -- rms.  */
 28590 #ifdef subprocesses
 28591         obj = Fget_buffer_process (Fcurrent_buffer ());
 28592         if (PROCESSP (obj))
 28593           {
 28594             p = decode_mode_spec_coding
 28595               (XPROCESS (obj)->decode_coding_system, p, eol_flag);
 28596             p = decode_mode_spec_coding
 28597               (XPROCESS (obj)->encode_coding_system, p, eol_flag);
 28598           }
 28599 #endif /* subprocesses */
 28600 #endif /* false */
 28601         *p = 0;
 28602         return decode_mode_spec_buf;
 28603       }
 28604     }
 28605 
 28606   if (STRINGP (obj))
 28607     {
 28608       *string = obj;
 28609       return SSDATA (obj);
 28610     }
 28611   else
 28612     return "";
 28613 }
 28614 
 28615 /* Return the number of lines between start_byte and end_byte in the
 28616    current buffer. */
 28617 
 28618 ptrdiff_t
 28619 count_lines (ptrdiff_t start_byte, ptrdiff_t end_byte)
 28620 {
 28621   ptrdiff_t ignored;
 28622   return display_count_lines (start_byte, end_byte, ZV, &ignored);
 28623 }
 28624 
 28625 /* Count up to COUNT lines starting from START_BYTE.  COUNT negative
 28626    means count lines back from START_BYTE.  But don't go beyond
 28627    LIMIT_BYTE.  Return the number of lines thus found (always
 28628    nonnegative).
 28629 
 28630    Set *BYTE_POS_PTR to the byte position where we stopped.  This is
 28631    either the position COUNT lines after/before START_BYTE, if we
 28632    found COUNT lines, or LIMIT_BYTE if we hit the limit before finding
 28633    COUNT lines.  */
 28634 
 28635 static ptrdiff_t
 28636 display_count_lines (ptrdiff_t start_byte,
 28637                      ptrdiff_t limit_byte, ptrdiff_t count,
 28638                      ptrdiff_t *byte_pos_ptr)
 28639 {
 28640   register unsigned char *cursor;
 28641   unsigned char *base;
 28642 
 28643   register ptrdiff_t ceiling;
 28644   register unsigned char *ceiling_addr;
 28645   ptrdiff_t orig_count = count;
 28646 
 28647   /* If we are not in selective display mode,
 28648      check only for newlines.  */
 28649   bool selective_display
 28650     = (!NILP (BVAR (current_buffer, selective_display))
 28651        && !FIXNUMP (BVAR (current_buffer, selective_display)));
 28652 
 28653   if (count > 0)
 28654     {
 28655       while (start_byte < limit_byte)
 28656         {
 28657           ceiling =  BUFFER_CEILING_OF (start_byte);
 28658           ceiling = min (limit_byte - 1, ceiling);
 28659           ceiling_addr = BYTE_POS_ADDR (ceiling) + 1;
 28660           base = (cursor = BYTE_POS_ADDR (start_byte));
 28661 
 28662           do
 28663             {
 28664               if (selective_display)
 28665                 {
 28666                   while (*cursor != '\n' && *cursor != 015
 28667                          && ++cursor != ceiling_addr)
 28668                     continue;
 28669                   if (cursor == ceiling_addr)
 28670                     break;
 28671                 }
 28672               else
 28673                 {
 28674                   cursor = memchr (cursor, '\n', ceiling_addr - cursor);
 28675                   if (! cursor)
 28676                     break;
 28677                 }
 28678 
 28679               cursor++;
 28680 
 28681               if (--count == 0)
 28682                 {
 28683                   start_byte += cursor - base;
 28684                   *byte_pos_ptr = start_byte;
 28685                   return orig_count;
 28686                 }
 28687             }
 28688           while (cursor < ceiling_addr);
 28689 
 28690           start_byte += ceiling_addr - base;
 28691         }
 28692     }
 28693   else
 28694     {
 28695       while (start_byte > limit_byte)
 28696         {
 28697           ceiling = BUFFER_FLOOR_OF (start_byte - 1);
 28698           ceiling = max (limit_byte, ceiling);
 28699           ceiling_addr = BYTE_POS_ADDR (ceiling);
 28700           base = (cursor = BYTE_POS_ADDR (start_byte - 1) + 1);
 28701           while (true)
 28702             {
 28703               if (selective_display)
 28704                 {
 28705                   while (--cursor >= ceiling_addr
 28706                          && *cursor != '\n' && *cursor != 015)
 28707                     continue;
 28708                   if (cursor < ceiling_addr)
 28709                     break;
 28710                 }
 28711               else
 28712                 {
 28713                   cursor = memrchr (ceiling_addr, '\n', cursor - ceiling_addr);
 28714                   if (! cursor)
 28715                     break;
 28716                 }
 28717 
 28718               if (++count == 0)
 28719                 {
 28720                   start_byte += cursor - base + 1;
 28721                   *byte_pos_ptr = start_byte;
 28722                   /* When scanning backwards, we should
 28723                      not count the newline posterior to which we stop.  */
 28724                   return - orig_count - 1;
 28725                 }
 28726             }
 28727           start_byte += ceiling_addr - base;
 28728         }
 28729     }
 28730 
 28731   *byte_pos_ptr = limit_byte;
 28732 
 28733   if (count < 0)
 28734     return - orig_count + count;
 28735   return orig_count - count;
 28736 
 28737 }
 28738 
 28739 
 28740 
 28741 /***********************************************************************
 28742                          Displaying strings
 28743  ***********************************************************************/
 28744 
 28745 /* Display a NUL-terminated string, starting with index START.
 28746 
 28747    If STRING is non-null, display that C string.  Otherwise, the Lisp
 28748    string LISP_STRING is displayed.  There's a case that STRING is
 28749    non-null and LISP_STRING is not nil.  It means STRING is a string
 28750    data of LISP_STRING.  In that case, we display LISP_STRING while
 28751    ignoring its text properties.
 28752 
 28753    If FACE_STRING is not nil, FACE_STRING_POS is a position in
 28754    FACE_STRING.  Display STRING or LISP_STRING with the face at
 28755    FACE_STRING_POS in FACE_STRING:
 28756 
 28757    Display the string in the environment given by IT, but use the
 28758    standard display table, temporarily.
 28759 
 28760    FIELD_WIDTH is the minimum number of output glyphs to produce.
 28761    If STRING has fewer characters than FIELD_WIDTH, pad to the right
 28762    with spaces.  If STRING has more characters, more than FIELD_WIDTH
 28763    glyphs will be produced.  FIELD_WIDTH <= 0 means don't pad.
 28764 
 28765    PRECISION is the maximum number of characters to output from
 28766    STRING.  PRECISION < 0  means don't truncate the string.
 28767 
 28768    This is roughly equivalent to printf format specifiers:
 28769 
 28770    FIELD_WIDTH  PRECISION       PRINTF
 28771    ----------------------------------------
 28772    -1           -1              %s
 28773    -1           10              %.10s
 28774    10           -1              %10s
 28775    20           10              %20.10s
 28776 
 28777    MULTIBYTE zero means do not display multibyte chars, > 0 means do
 28778    display them, and < 0 means obey the current buffer's value of
 28779    enable_multibyte_characters.
 28780 
 28781    Value is the number of columns displayed.  */
 28782 
 28783 static int
 28784 display_string (const char *string, Lisp_Object lisp_string, Lisp_Object face_string,
 28785                 ptrdiff_t face_string_pos, ptrdiff_t start, struct it *it,
 28786                 int field_width, int precision, int max_x, int multibyte)
 28787 {
 28788   int hpos_at_start = it->hpos;
 28789   int saved_face_id = it->face_id;
 28790   struct glyph_row *row = it->glyph_row;
 28791   ptrdiff_t it_charpos;
 28792 
 28793   /* Initialize the iterator IT for iteration over STRING beginning
 28794      with index START.  */
 28795   reseat_to_string (it, NILP (lisp_string) ? string : NULL, lisp_string,
 28796                     start, precision, field_width, multibyte);
 28797 
 28798   if (string && STRINGP (lisp_string))
 28799     /* LISP_STRING is the one returned by decode_mode_spec.  We should
 28800        ignore its text properties.  */
 28801     it->stop_charpos = it->end_charpos;
 28802 
 28803   /* If displaying STRING, set up the face of the iterator from
 28804      FACE_STRING, if that's given.  */
 28805   if (STRINGP (face_string))
 28806     {
 28807       ptrdiff_t endptr;
 28808       struct face *face;
 28809 
 28810       it->face_id
 28811         = face_at_string_position (it->w, face_string, face_string_pos,
 28812                                    0, &endptr, it->base_face_id, false, 0);
 28813       face = FACE_FROM_ID (it->f, it->face_id);
 28814       it->face_box_p = face->box != FACE_NO_BOX;
 28815 
 28816       /* If we have a display spec, but there's no Lisp string being
 28817          displayed, then check whether we've got one from the
 28818          :propertize being passed in and use that.  */
 28819       if (NILP (lisp_string))
 28820         {
 28821           Lisp_Object display = Fget_text_property (make_fixnum (0), Qdisplay,
 28822                                                     face_string);
 28823           if (!NILP (display))
 28824             {
 28825               Lisp_Object min_width = plist_get (display, Qmin_width);
 28826               if (!NILP (min_width))
 28827                 display_min_width (it, 0, face_string, min_width);
 28828             }
 28829         }
 28830     }
 28831 
 28832   /* Set max_x to the maximum allowed X position.  Don't let it go
 28833      beyond the right edge of the window.  */
 28834   if (max_x <= 0)
 28835     max_x = it->last_visible_x;
 28836   else
 28837     max_x = min (max_x, it->last_visible_x);
 28838 
 28839   /* Skip over display elements that are not visible because IT->w is
 28840      hscrolled.  */
 28841   if (it->current_x < it->first_visible_x)
 28842     move_it_in_display_line_to (it, 100000, it->first_visible_x,
 28843                                 MOVE_TO_POS | MOVE_TO_X);
 28844 
 28845   row->ascent = it->max_ascent;
 28846   row->height = it->max_ascent + it->max_descent;
 28847   row->phys_ascent = it->max_phys_ascent;
 28848   row->phys_height = it->max_phys_ascent + it->max_phys_descent;
 28849   row->extra_line_spacing = it->max_extra_line_spacing;
 28850 
 28851   if (STRINGP (it->string))
 28852     it_charpos = IT_STRING_CHARPOS (*it);
 28853   else
 28854     it_charpos = IT_CHARPOS (*it);
 28855 
 28856   /* This condition is for the case that we are called with current_x
 28857      past last_visible_x.  */
 28858   while (it->current_x < max_x)
 28859     {
 28860       int x_before, x, n_glyphs_before, i, nglyphs;
 28861 
 28862       /* Get the next display element.  */
 28863       if (!get_next_display_element (it))
 28864         break;
 28865 
 28866       /* Produce glyphs.  */
 28867       x_before = it->current_x;
 28868       n_glyphs_before = row->used[TEXT_AREA];
 28869       PRODUCE_GLYPHS (it);
 28870 
 28871       nglyphs = row->used[TEXT_AREA] - n_glyphs_before;
 28872       i = 0;
 28873       x = x_before;
 28874       while (i < nglyphs)
 28875         {
 28876           struct glyph *glyph = row->glyphs[TEXT_AREA] + n_glyphs_before + i;
 28877 
 28878           if (it->line_wrap != TRUNCATE
 28879               && x + glyph->pixel_width > max_x)
 28880             {
 28881               /* End of continued line or max_x reached.  */
 28882               if (CHAR_GLYPH_PADDING_P (*glyph))
 28883                 {
 28884                   /* A wide character is unbreakable.  */
 28885                   if (row->reversed_p)
 28886                     unproduce_glyphs (it, row->used[TEXT_AREA]
 28887                                       - n_glyphs_before);
 28888                   row->used[TEXT_AREA] = n_glyphs_before;
 28889                   it->current_x = x_before;
 28890                 }
 28891               else
 28892                 {
 28893                   if (row->reversed_p)
 28894                     unproduce_glyphs (it, row->used[TEXT_AREA]
 28895                                       - (n_glyphs_before + i));
 28896                   row->used[TEXT_AREA] = n_glyphs_before + i;
 28897                   it->current_x = x;
 28898                 }
 28899               break;
 28900             }
 28901           else if (x + glyph->pixel_width >= it->first_visible_x)
 28902             {
 28903               /* Glyph is at least partially visible.  */
 28904               ++it->hpos;
 28905               if (x < it->first_visible_x)
 28906                 row->x = x - it->first_visible_x;
 28907             }
 28908           else
 28909             {
 28910               /* Glyph is off the left margin of the display area.
 28911                  Should not happen.  */
 28912               emacs_abort ();
 28913             }
 28914 
 28915           row->ascent = max (row->ascent, it->max_ascent);
 28916           row->height = max (row->height, it->max_ascent + it->max_descent);
 28917           row->phys_ascent = max (row->phys_ascent, it->max_phys_ascent);
 28918           row->phys_height = max (row->phys_height,
 28919                                   it->max_phys_ascent + it->max_phys_descent);
 28920           row->extra_line_spacing = max (row->extra_line_spacing,
 28921                                          it->max_extra_line_spacing);
 28922           x += glyph->pixel_width;
 28923           ++i;
 28924         }
 28925 
 28926       /* Stop if max_x reached.  */
 28927       if (i < nglyphs)
 28928         break;
 28929 
 28930       /* Stop at line ends.  */
 28931       if (ITERATOR_AT_END_OF_LINE_P (it))
 28932         {
 28933           it->continuation_lines_width = 0;
 28934           break;
 28935         }
 28936 
 28937       set_iterator_to_next (it, true);
 28938       if (STRINGP (it->string))
 28939         it_charpos = IT_STRING_CHARPOS (*it);
 28940       else
 28941         it_charpos = IT_CHARPOS (*it);
 28942 
 28943       /* Stop if truncating at the right edge.  */
 28944       if (it->line_wrap == TRUNCATE
 28945           && it->current_x >= it->last_visible_x)
 28946         {
 28947           /* Add truncation mark, but don't do it if the line is
 28948              truncated at a padding space.  */
 28949           /* Need to do the below for the last string character as
 28950              well, since it could be a double-width character, in
 28951              which case the previous character ends before
 28952              last_visible_x.  Thus, comparison with <=, not <.  */
 28953           if (it_charpos <= it->string_nchars)
 28954             {
 28955               if (!FRAME_WINDOW_P (it->f))
 28956                 {
 28957                   int ii, n;
 28958 
 28959                   if (it->current_x > it->last_visible_x)
 28960                     {
 28961                       /* This flag is true if we are displaying mode
 28962                          line, false for header-line or tab-line.  */
 28963                       bool mode_line_p = false;
 28964 
 28965                       /* ROW->mode_line_p is true if we display mode
 28966                          line or header-line or tab-line.  */
 28967                       if (row->mode_line_p)
 28968                         {
 28969                           struct window *w = it->w;
 28970                           if (row == MATRIX_MODE_LINE_ROW (w->desired_matrix))
 28971                             mode_line_p = true;
 28972                         }
 28973                       if (!row->reversed_p)
 28974                         {
 28975                           for (ii = row->used[TEXT_AREA] - 1; ii > 0; --ii)
 28976                             if (!CHAR_GLYPH_PADDING_P (row->glyphs[TEXT_AREA][ii]))
 28977                               break;
 28978                         }
 28979                       else
 28980                         {
 28981                           for (ii = 0; ii < row->used[TEXT_AREA]; ii++)
 28982                             if (!CHAR_GLYPH_PADDING_P (row->glyphs[TEXT_AREA][ii]))
 28983                               break;
 28984                           unproduce_glyphs (it, ii + 1);
 28985                           ii = row->used[TEXT_AREA] - (ii + 1);
 28986                         }
 28987                       for (n = row->used[TEXT_AREA]; ii < n; ++ii)
 28988                         {
 28989                           row->used[TEXT_AREA] = ii;
 28990                           if (row->mode_line_p)
 28991                             pad_mode_line (it, mode_line_p);
 28992                           else
 28993                             produce_special_glyphs (it, IT_TRUNCATION);
 28994                         }
 28995                     }
 28996                   produce_special_glyphs (it, IT_TRUNCATION);
 28997                 }
 28998               row->truncated_on_right_p = true;
 28999             }
 29000           break;
 29001         }
 29002     }
 29003 
 29004   /* Maybe insert a truncation at the left.  */
 29005   if (it->first_visible_x
 29006       && it_charpos > 0)
 29007     {
 29008       if (!FRAME_WINDOW_P (it->f)
 29009           || (row->reversed_p
 29010               ? WINDOW_RIGHT_FRINGE_WIDTH (it->w)
 29011               : WINDOW_LEFT_FRINGE_WIDTH (it->w)) == 0)
 29012         insert_left_trunc_glyphs (it);
 29013       row->truncated_on_left_p = true;
 29014     }
 29015 
 29016   it->face_id = saved_face_id;
 29017 
 29018   /* Value is number of columns displayed.  */
 29019   return it->hpos - hpos_at_start;
 29020 }
 29021 
 29022 
 29023 
 29024 /* This is like a combination of memq and assq.  Return 1/2 if PROPVAL
 29025    appears as an element of LIST or as the car of an element of LIST.
 29026    If PROPVAL is a list, compare each element against LIST in that
 29027    way, and return 1/2 if any element of PROPVAL is found in LIST.
 29028    Otherwise return 0.  This function cannot quit.
 29029    The return value is 2 if the text is invisible but with an ellipsis
 29030    and 1 if it's invisible and without an ellipsis.  */
 29031 
 29032 int
 29033 invisible_prop (Lisp_Object propval, Lisp_Object list)
 29034 {
 29035   Lisp_Object tail, proptail;
 29036 
 29037   for (tail = list; CONSP (tail); tail = XCDR (tail))
 29038     {
 29039       register Lisp_Object tem;
 29040       tem = XCAR (tail);
 29041       if (EQ (propval, tem))
 29042         return 1;
 29043       if (CONSP (tem) && EQ (propval, XCAR (tem)))
 29044         return NILP (XCDR (tem)) ? 1 : 2;
 29045     }
 29046 
 29047   if (CONSP (propval))
 29048     {
 29049       for (proptail = propval; CONSP (proptail); proptail = XCDR (proptail))
 29050         {
 29051           Lisp_Object propelt;
 29052           propelt = XCAR (proptail);
 29053           for (tail = list; CONSP (tail); tail = XCDR (tail))
 29054             {
 29055               register Lisp_Object tem;
 29056               tem = XCAR (tail);
 29057               if (EQ (propelt, tem))
 29058                 return 1;
 29059               if (CONSP (tem) && EQ (propelt, XCAR (tem)))
 29060                 return NILP (XCDR (tem)) ? 1 : 2;
 29061             }
 29062         }
 29063     }
 29064 
 29065   return 0;
 29066 }
 29067 
 29068 DEFUN ("invisible-p", Finvisible_p, Sinvisible_p, 1, 1, 0,
 29069        doc: /* Non-nil if text properties at POS cause text there to be currently invisible.
 29070 POS should be a marker or a buffer position; the value of the `invisible'
 29071 property at that position in the current buffer is examined.
 29072 POS can also be the actual value of the `invisible' text or overlay
 29073 property of the text of interest, in which case the value itself is
 29074 examined.
 29075 
 29076 The non-nil value returned can be t for currently invisible text that is
 29077 entirely hidden on display, or some other non-nil, non-t value if the
 29078 text is replaced by an ellipsis.
 29079 
 29080 Note that whether text with `invisible' property is actually hidden on
 29081 display may depend on `buffer-invisibility-spec', which see.  */)
 29082   (Lisp_Object pos)
 29083 {
 29084   Lisp_Object prop
 29085     = (FIXNATP (pos) || MARKERP (pos)
 29086        ? Fget_char_property (pos, Qinvisible, Qnil)
 29087        : pos);
 29088   int invis = TEXT_PROP_MEANS_INVISIBLE (prop);
 29089   return (invis == 0 ? Qnil
 29090           : invis == 1 ? Qt
 29091           : make_fixnum (invis));
 29092 }
 29093 
 29094 /* Calculate a width or height in pixels from a specification using
 29095    the following elements:
 29096 
 29097    SPEC ::=
 29098      NUM      - a (fractional) multiple of the default font width/height
 29099      (NUM)    - specifies exactly NUM pixels
 29100      UNIT     - a fixed number of pixels, see below.
 29101      ELEMENT  - size of a display element in pixels, see below.
 29102      (NUM . SPEC) - equals NUM * SPEC
 29103      (+ SPEC SPEC ...)  - add pixel values
 29104      (- SPEC SPEC ...)  - subtract pixel values
 29105      (- SPEC)           - negate pixel value
 29106 
 29107    NUM ::=
 29108      INT or FLOAT   - a number constant
 29109      SYMBOL         - use symbol's (buffer local) variable binding.
 29110 
 29111    UNIT ::=
 29112      in       - pixels per inch  *)
 29113      mm       - pixels per 1/1000 meter  *)
 29114      cm       - pixels per 1/100 meter   *)
 29115      width    - width of current font in pixels.
 29116      height   - height of current font in pixels.
 29117 
 29118      *) using the ratio(s) defined in display-pixels-per-inch.
 29119 
 29120    ELEMENT ::=
 29121 
 29122      left-fringe          - left fringe width in pixels
 29123      right-fringe         - right fringe width in pixels
 29124 
 29125      left-margin          - left margin width in pixels
 29126      right-margin         - right margin width in pixels
 29127 
 29128      scroll-bar           - scroll-bar area width in pixels
 29129 
 29130    Examples:
 29131 
 29132    Pixels corresponding to 5 inches:
 29133      (5 . in)
 29134 
 29135    Total width of non-text areas on left side of window (if scroll-bar is on left):
 29136      '(space :width (+ left-fringe left-margin scroll-bar))
 29137 
 29138    Align to first text column (in header line):
 29139      '(space :align-to 0)
 29140 
 29141    Align to middle of text area minus half the width of variable `my-image'
 29142    containing a loaded image:
 29143      '(space :align-to (0.5 . (- text my-image)))
 29144 
 29145    Width of left margin minus width of 1 character in the default font:
 29146      '(space :width (- left-margin 1))
 29147 
 29148    Width of left margin minus width of 2 characters in the current font:
 29149      '(space :width (- left-margin (2 . width)))
 29150 
 29151    Center 1 character over left-margin (in header line):
 29152      '(space :align-to (+ left-margin (0.5 . left-margin) -0.5))
 29153 
 29154    Different ways to express width of left fringe plus left margin minus one pixel:
 29155      '(space :width (- (+ left-fringe left-margin) (1)))
 29156      '(space :width (+ left-fringe left-margin (- (1))))
 29157      '(space :width (+ left-fringe left-margin (-1)))
 29158 
 29159    If ALIGN_TO is NULL, returns the result in *RES.  If ALIGN_TO is
 29160    non-NULL, the value of *ALIGN_TO is a window-relative pixel
 29161    coordinate, and *RES is the additional pixel width from that point
 29162    till the end of the stretch glyph.
 29163 
 29164    WIDTH_P non-zero means take the width dimension or X coordinate of
 29165    the object specified by PROP, WIDTH_P zero means take the height
 29166    dimension or the Y coordinate.  (Therefore, if ALIGN_TO is
 29167    non-NULL, WIDTH_P should be non-zero.)
 29168 
 29169    FONT is the font of the face of the surrounding text.
 29170 
 29171    The return value is non-zero if width or height were successfully
 29172    calculated, i.e. if PROP is a valid spec.  */
 29173 
 29174 static bool
 29175 calc_pixel_width_or_height (double *res, struct it *it, Lisp_Object prop,
 29176                             struct font *font, bool width_p, int *align_to)
 29177 {
 29178   /* Don't adjust for line number if we didn't yet produce it for this
 29179      screen line.  This is for when this function is called from
 29180      move_it_in_display_line_to that was called by display_line to get
 29181      past the glyphs hscrolled off the left side of the window.  */
 29182   int lnum_pixel_width = it->line_number_produced_p ? it->lnum_pixel_width : 0;
 29183   double pixels;
 29184 
 29185 # define OK_PIXELS(val) (*res = (val), true)
 29186 # define OK_ALIGN_TO(val) (*align_to = (val), true)
 29187 
 29188   if (NILP (prop))
 29189     return OK_PIXELS (0);
 29190 
 29191   eassert (FRAME_LIVE_P (it->f));
 29192 
 29193   if (SYMBOLP (prop))
 29194     {
 29195       if (SCHARS (SYMBOL_NAME (prop)) == 2)
 29196         {
 29197           char *unit = SSDATA (SYMBOL_NAME (prop));
 29198 
 29199           /* The UNIT expression, e.g. as part of (NUM . UNIT).  */
 29200           if (unit[0] == 'i' && unit[1] == 'n')
 29201             pixels = 1.0;
 29202           else if (unit[0] == 'm' && unit[1] == 'm')
 29203             pixels = 25.4;
 29204           else if (unit[0] == 'c' && unit[1] == 'm')
 29205             pixels = 2.54;
 29206           else
 29207             pixels = 0;
 29208           if (pixels > 0)
 29209             {
 29210               double ppi = (width_p ? FRAME_RES_X (it->f)
 29211                             : FRAME_RES_Y (it->f));
 29212 
 29213               if (ppi > 0)
 29214                 return OK_PIXELS (ppi / pixels);
 29215               return false;
 29216             }
 29217         }
 29218 
 29219 #ifdef HAVE_WINDOW_SYSTEM
 29220       /* 'height': the height of FONT.  */
 29221       if (EQ (prop, Qheight))
 29222         return OK_PIXELS (font
 29223                           ? normal_char_height (font, -1)
 29224                           : FRAME_LINE_HEIGHT (it->f));
 29225       /* 'width': the width of FONT.  */
 29226       if (EQ (prop, Qwidth))
 29227         return OK_PIXELS (font
 29228                           ? FONT_WIDTH (font)
 29229                           : FRAME_COLUMN_WIDTH (it->f));
 29230 #else
 29231       if (EQ (prop, Qheight) || EQ (prop, Qwidth))
 29232         return OK_PIXELS (1);
 29233 #endif
 29234 
 29235       /* 'text': the width or height of the text area.  */
 29236       if (EQ (prop, Qtext))
 29237           return OK_PIXELS (width_p
 29238                             ? (window_box_width (it->w, TEXT_AREA)
 29239                                - lnum_pixel_width)
 29240                             : WINDOW_BOX_HEIGHT_NO_MODE_LINE (it->w));
 29241 
 29242       /* ':align_to'.  First time we compute the value, window
 29243          elements are interpreted as the position of the element's
 29244          left edge.  */
 29245       if (align_to && *align_to < 0)
 29246         {
 29247           *res = 0;
 29248           /* 'left': left edge of the text area.  */
 29249           if (EQ (prop, Qleft))
 29250             return OK_ALIGN_TO (window_box_left_offset (it->w, TEXT_AREA)
 29251                                 + lnum_pixel_width);
 29252           /* 'right': right edge of the text area.  */
 29253           if (EQ (prop, Qright))
 29254             return OK_ALIGN_TO (window_box_right_offset (it->w, TEXT_AREA));
 29255           /* 'center': the center of the text area.  */
 29256           if (EQ (prop, Qcenter))
 29257             return OK_ALIGN_TO (window_box_left_offset (it->w, TEXT_AREA)
 29258                                 + lnum_pixel_width
 29259                                 + window_box_width (it->w, TEXT_AREA) / 2);
 29260           /* 'left-fringe': left edge of the left fringe.  */
 29261           if (EQ (prop, Qleft_fringe))
 29262             return OK_ALIGN_TO (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (it->w)
 29263                                 ? WINDOW_LEFT_SCROLL_BAR_AREA_WIDTH (it->w)
 29264                                 : window_box_right_offset (it->w, LEFT_MARGIN_AREA));
 29265           /* 'right-fringe': left edge of the right fringe.  */
 29266           if (EQ (prop, Qright_fringe))
 29267             return OK_ALIGN_TO (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (it->w)
 29268                                 ? window_box_right_offset (it->w, RIGHT_MARGIN_AREA)
 29269                                 : window_box_right_offset (it->w, TEXT_AREA));
 29270           /* 'left-margin': left edge of the left display margin.  */
 29271           if (EQ (prop, Qleft_margin))
 29272             return OK_ALIGN_TO (window_box_left_offset (it->w, LEFT_MARGIN_AREA));
 29273           /* 'right-margin': left edge of the right display margin.  */
 29274           if (EQ (prop, Qright_margin))
 29275             return OK_ALIGN_TO (window_box_left_offset (it->w, RIGHT_MARGIN_AREA));
 29276           /* 'scroll-bar': left edge of the vertical scroll bar.  */
 29277           if (EQ (prop, Qscroll_bar))
 29278             return OK_ALIGN_TO (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (it->w)
 29279                                 ? 0
 29280                                 : (window_box_right_offset (it->w, RIGHT_MARGIN_AREA)
 29281                                    + (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (it->w)
 29282                                       ? WINDOW_RIGHT_FRINGE_WIDTH (it->w)
 29283                                       : 0)));
 29284         }
 29285       else
 29286         {
 29287           /* Otherwise, the elements stand for their width.  */
 29288           if (EQ (prop, Qleft_fringe))
 29289             return OK_PIXELS (WINDOW_LEFT_FRINGE_WIDTH (it->w));
 29290           if (EQ (prop, Qright_fringe))
 29291             return OK_PIXELS (WINDOW_RIGHT_FRINGE_WIDTH (it->w));
 29292           if (EQ (prop, Qleft_margin))
 29293             return OK_PIXELS (WINDOW_LEFT_MARGIN_WIDTH (it->w));
 29294           if (EQ (prop, Qright_margin))
 29295             return OK_PIXELS (WINDOW_RIGHT_MARGIN_WIDTH (it->w));
 29296           if (EQ (prop, Qscroll_bar))
 29297             return OK_PIXELS (WINDOW_SCROLL_BAR_AREA_WIDTH (it->w));
 29298         }
 29299 
 29300       prop = buffer_local_value (prop, it->w->contents);
 29301       if (BASE_EQ (prop, Qunbound))
 29302         prop = Qnil;
 29303     }
 29304 
 29305   if (NUMBERP (prop))
 29306     {
 29307       int base_unit = (width_p
 29308                        ? FRAME_COLUMN_WIDTH (it->f)
 29309                        : FRAME_LINE_HEIGHT (it->f));
 29310       if (width_p && align_to && *align_to < 0)
 29311         return OK_PIXELS (XFLOATINT (prop) * base_unit + lnum_pixel_width);
 29312       return OK_PIXELS (XFLOATINT (prop) * base_unit);
 29313     }
 29314 
 29315   if (CONSP (prop))
 29316     {
 29317       Lisp_Object car = XCAR (prop);
 29318       Lisp_Object cdr = XCDR (prop);
 29319 
 29320       if (SYMBOLP (car))
 29321         {
 29322 #ifdef HAVE_WINDOW_SYSTEM
 29323           /* '(image PROPS...)': width or height of the specified image.  */
 29324           if (FRAME_WINDOW_P (it->f)
 29325               && valid_image_p (prop))
 29326             {
 29327               ptrdiff_t id = lookup_image (it->f, prop, it->face_id);
 29328               struct image *img = IMAGE_FROM_ID (it->f, id);
 29329 
 29330               return OK_PIXELS (width_p ? img->width : img->height);
 29331             }
 29332           /* '(xwidget PROPS...)': dimensions of the specified xwidget.  */
 29333           if (FRAME_WINDOW_P (it->f) && valid_xwidget_spec_p (prop))
 29334             {
 29335               /* TODO: Don't return dummy size.  */
 29336               return OK_PIXELS (100);
 29337             }
 29338 #endif
 29339           /* '(+ EXPR...)' or '(- EXPR...)' add or subtract
 29340              recursively calculated values.  */
 29341           if (EQ (car, Qplus) || EQ (car, Qminus))
 29342             {
 29343               bool first = true;
 29344               double px;
 29345 
 29346               pixels = 0;
 29347               while (CONSP (cdr))
 29348                 {
 29349                   if (!calc_pixel_width_or_height (&px, it, XCAR (cdr),
 29350                                                    font, width_p, align_to))
 29351                     return false;
 29352                   if (first)
 29353                     pixels = (EQ (car, Qplus) ? px : -px), first = false;
 29354                   else
 29355                     pixels += px;
 29356                   cdr = XCDR (cdr);
 29357                 }
 29358               if (EQ (car, Qminus))
 29359                 pixels = -pixels;
 29360               return OK_PIXELS (pixels);
 29361             }
 29362 
 29363           car = buffer_local_value (car, it->w->contents);
 29364           if (BASE_EQ (car, Qunbound))
 29365             car = Qnil;
 29366         }
 29367 
 29368       /* '(NUM)': absolute number of pixels.  */
 29369       if (NUMBERP (car))
 29370         {
 29371           double fact;
 29372           int offset =
 29373             width_p && align_to && *align_to < 0 ? lnum_pixel_width : 0;
 29374           pixels = XFLOATINT (car);
 29375           if (NILP (cdr))
 29376             return OK_PIXELS (pixels + offset);
 29377           if (calc_pixel_width_or_height (&fact, it, cdr,
 29378                                           font, width_p, align_to))
 29379             return OK_PIXELS (pixels * fact + offset);
 29380           return false;
 29381         }
 29382 
 29383       return false;
 29384     }
 29385 
 29386   return false;
 29387 }
 29388 
 29389 void
 29390 get_font_ascent_descent (struct font *font, int *ascent, int *descent)
 29391 {
 29392 #ifdef HAVE_WINDOW_SYSTEM
 29393   normal_char_ascent_descent (font, -1, ascent, descent);
 29394 #else
 29395   *ascent = 1;
 29396   *descent = 0;
 29397 #endif
 29398 }
 29399 
 29400 
 29401 /***********************************************************************
 29402                              Glyph Display
 29403  ***********************************************************************/
 29404 
 29405 #ifdef HAVE_WINDOW_SYSTEM
 29406 
 29407 #ifdef GLYPH_DEBUG
 29408 
 29409 extern void dump_glyph_string (struct glyph_string *) EXTERNALLY_VISIBLE;
 29410 void
 29411 dump_glyph_string (struct glyph_string *s)
 29412 {
 29413   fputs ("glyph string\n", stderr);
 29414   fprintf (stderr, "  x, y, w, h = %d, %d, %d, %d\n",
 29415            s->x, s->y, s->width, s->height);
 29416   fprintf (stderr, "  ybase = %d\n", s->ybase);
 29417   fprintf (stderr, "  hl = %u\n", s->hl);
 29418   fprintf (stderr, "  left overhang = %d, right = %d\n",
 29419            s->left_overhang, s->right_overhang);
 29420   fprintf (stderr, "  nchars = %d\n", s->nchars);
 29421   fprintf (stderr, "  extends to end of line = %d\n",
 29422            s->extends_to_end_of_line_p);
 29423   fprintf (stderr, "  font height = %d\n", FONT_HEIGHT (s->font));
 29424   fprintf (stderr, "  bg width = %d\n", s->background_width);
 29425 }
 29426 
 29427 #endif /* GLYPH_DEBUG */
 29428 
 29429 /* Initialize glyph string S.  CHAR2B is a suitably allocated vector
 29430    of 2-byte unsigned integers for S; it can't be allocated in
 29431    init_glyph_string because it must be allocated via `alloca'.  W
 29432    is the window on which S is drawn.  ROW and AREA are the glyph row
 29433    and area within the row from which S is constructed.  START is the
 29434    index of the first glyph structure covered by S.  HL is a
 29435    face-override for drawing S.  */
 29436 
 29437 #ifdef HAVE_NTGUI
 29438 /* We set inhibit-quit here due to paranoia: get_frame_dc acquires the
 29439    critical section, and we cannot QUIT while we hold the critical
 29440    section.  If any of the code run by callers of ALLOCATE_HDC happens
 29441    to call Lisp (might be possible due to all the hooks lying around),
 29442    we must prevent it from quitting.  */
 29443 # define ALLOCATE_HDC(hdc, f)                   \
 29444   Lisp_Object prev_quit = Vinhibit_quit;        \
 29445   Vinhibit_quit = Qt;                           \
 29446   HDC hdc = get_frame_dc ((f))
 29447 # define RELEASE_HDC(hdc, f)                    \
 29448   release_frame_dc ((f), (hdc));                \
 29449   Vinhibit_quit = prev_quit
 29450 #else
 29451 # define ALLOCATE_HDC(hdc, f)
 29452 # define RELEASE_HDC(hdc, f)
 29453 #endif
 29454 
 29455 static void
 29456 init_glyph_string (struct glyph_string *s,
 29457 #ifdef HAVE_NTGUI
 29458                    HDC hdc,
 29459 #endif
 29460                    unsigned *char2b, struct window *w, struct glyph_row *row,
 29461                    enum glyph_row_area area, int start, enum draw_glyphs_face hl)
 29462 {
 29463   memset (s, 0, sizeof *s);
 29464   s->w = w;
 29465   s->f = XFRAME (w->frame);
 29466 #ifdef HAVE_NTGUI
 29467   s->hdc = hdc;
 29468 #endif
 29469   s->char2b = char2b;
 29470   s->hl = hl;
 29471   s->row = row;
 29472   s->area = area;
 29473   s->first_glyph = row->glyphs[area] + start;
 29474   s->height = row->height;
 29475   s->y = WINDOW_TO_FRAME_PIXEL_Y (w, row->y);
 29476   s->ybase = s->y + row->ascent;
 29477 }
 29478 
 29479 
 29480 /* Append the list of glyph strings with head H and tail T to the list
 29481    with head *HEAD and tail *TAIL.  Set *HEAD and *TAIL to the result.  */
 29482 
 29483 static void
 29484 append_glyph_string_lists (struct glyph_string **head, struct glyph_string **tail,
 29485                            struct glyph_string *h, struct glyph_string *t)
 29486 {
 29487   if (h)
 29488     {
 29489       if (*head)
 29490         (*tail)->next = h;
 29491       else
 29492         *head = h;
 29493       h->prev = *tail;
 29494       *tail = t;
 29495     }
 29496 }
 29497 
 29498 
 29499 /* Prepend the list of glyph strings with head H and tail T to the
 29500    list with head *HEAD and tail *TAIL.  Set *HEAD and *TAIL to the
 29501    result.  */
 29502 
 29503 static void
 29504 prepend_glyph_string_lists (struct glyph_string **head, struct glyph_string **tail,
 29505                             struct glyph_string *h, struct glyph_string *t)
 29506 {
 29507   if (h)
 29508     {
 29509       if (*head)
 29510         (*head)->prev = t;
 29511       else
 29512         *tail = t;
 29513       t->next = *head;
 29514       *head = h;
 29515     }
 29516 }
 29517 
 29518 
 29519 /* Append glyph string S to the list with head *HEAD and tail *TAIL.
 29520    Set *HEAD and *TAIL to the resulting list.  */
 29521 
 29522 static void
 29523 append_glyph_string (struct glyph_string **head, struct glyph_string **tail,
 29524                      struct glyph_string *s)
 29525 {
 29526   s->next = s->prev = NULL;
 29527   append_glyph_string_lists (head, tail, s, s);
 29528 }
 29529 
 29530 
 29531 /* Get face and two-byte form of character C in face FACE_ID on frame F.
 29532    The encoding of C is returned in *CHAR2B.  DISPLAY_P means
 29533    make sure that X resources for the face returned are allocated.
 29534    Value is a pointer to a realized face that is ready for display if
 29535    DISPLAY_P.  */
 29536 
 29537 static struct face *
 29538 get_char_face_and_encoding (struct frame *f, int c, int face_id,
 29539                             unsigned *char2b, bool display_p)
 29540 {
 29541   struct face *face = FACE_FROM_ID (f, face_id);
 29542   unsigned code = 0;
 29543 
 29544   if (face->font)
 29545     {
 29546       code = face->font->driver->encode_char (face->font, c);
 29547 
 29548       if (code == FONT_INVALID_CODE)
 29549         code = 0;
 29550     }
 29551   /* Ensure that the code is only 2 bytes wide.  */
 29552   *char2b = code & 0xFFFF;
 29553 
 29554   /* Make sure X resources of the face are allocated.  */
 29555 #ifdef HAVE_X_WINDOWS
 29556   if (display_p)
 29557 #endif
 29558     {
 29559       eassert (face != NULL);
 29560       prepare_face_for_display (f, face);
 29561     }
 29562 
 29563   return face;
 29564 }
 29565 
 29566 
 29567 /* Get face and two-byte form of character glyph GLYPH on frame F.
 29568    The encoding of GLYPH->u.ch is returned in *CHAR2B.  Value is
 29569    a pointer to a realized face that is ready for display.  */
 29570 
 29571 static struct face *
 29572 get_glyph_face_and_encoding (struct frame *f, struct glyph *glyph,
 29573                              unsigned *char2b)
 29574 {
 29575   struct face *face;
 29576   unsigned code = 0;
 29577 
 29578   eassert (glyph->type == CHAR_GLYPH);
 29579   face = FACE_FROM_ID (f, glyph->face_id);
 29580 
 29581   /* Make sure X resources of the face are allocated.  */
 29582   prepare_face_for_display (f, face);
 29583 
 29584   if (face->font)
 29585     {
 29586       if (CHAR_BYTE8_P (glyph->u.ch))
 29587         code = CHAR_TO_BYTE8 (glyph->u.ch);
 29588       else
 29589         code = face->font->driver->encode_char (face->font, glyph->u.ch);
 29590 
 29591       if (code == FONT_INVALID_CODE)
 29592         code = 0;
 29593     }
 29594 
 29595   /* Ensure that the code is only 2 bytes wide.  */
 29596   *char2b = code & 0xFFFF;
 29597   return face;
 29598 }
 29599 
 29600 
 29601 /* Get glyph code of character C in FONT in the two-byte form CHAR2B.
 29602    Return true iff FONT has a glyph for C.  */
 29603 
 29604 static bool
 29605 get_char_glyph_code (int c, struct font *font, unsigned *char2b)
 29606 {
 29607   unsigned code;
 29608 
 29609   if (CHAR_BYTE8_P (c))
 29610     code = CHAR_TO_BYTE8 (c);
 29611   else
 29612     code = font->driver->encode_char (font, c);
 29613 
 29614   if (code == FONT_INVALID_CODE)
 29615     return false;
 29616 
 29617   /* Ensure that the code is only 2 bytes wide.  */
 29618   *char2b = code & 0xFFFF;
 29619   return true;
 29620 }
 29621 
 29622 
 29623 /* Fill glyph string S with composition components specified by S->cmp.
 29624 
 29625    BASE_FACE is the base face of the composition.
 29626    S->cmp_from is the index of the first component for S.
 29627 
 29628    OVERLAPS non-zero means S should draw the foreground only, and use
 29629    its physical height for clipping.  See also draw_glyphs.
 29630 
 29631    Value is the index of a component not in S.  */
 29632 
 29633 static int
 29634 fill_composite_glyph_string (struct glyph_string *s, struct face *base_face,
 29635                              int overlaps)
 29636 {
 29637   int i;
 29638   /* For all glyphs of this composition, starting at the offset
 29639      S->cmp_from, until we reach the end of the definition or encounter a
 29640      glyph that requires the different face, add it to S.  */
 29641   struct face *face;
 29642 
 29643   eassert (s);
 29644 
 29645   s->for_overlaps = overlaps;
 29646   s->face = NULL;
 29647   s->font = NULL;
 29648   for (i = s->cmp_from; i < s->cmp->glyph_len; i++)
 29649     {
 29650       int c = COMPOSITION_GLYPH (s->cmp, i);
 29651 
 29652       /* TAB in a composition means display glyphs with padding space
 29653          on the left or right.  */
 29654       if (c != '\t')
 29655         {
 29656           int face_id = FACE_FOR_CHAR (s->f, base_face->ascii_face, c,
 29657                                        -1, Qnil);
 29658 
 29659           face = get_char_face_and_encoding (s->f, c, face_id,
 29660                                              s->char2b + i, true);
 29661           if (face)
 29662             {
 29663               if (! s->face)
 29664                 {
 29665                   s->face = face;
 29666                   s->font = s->face->font;
 29667                 }
 29668               else if (s->face != face)
 29669                 break;
 29670             }
 29671         }
 29672       ++s->nchars;
 29673     }
 29674   s->cmp_to = i;
 29675 
 29676   if (s->face == NULL)
 29677     {
 29678       s->face = base_face->ascii_face;
 29679       s->font = s->face->font;
 29680     }
 29681 
 29682   if (s->hl == DRAW_MOUSE_FACE
 29683       || (s->hl == DRAW_CURSOR
 29684           && MATRIX_ROW (s->w->current_matrix,
 29685                          s->w->phys_cursor.vpos)->mouse_face_p
 29686           && cursor_in_mouse_face_p (s->w)))
 29687     {
 29688       int c = COMPOSITION_GLYPH (s->cmp, 0);
 29689       Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (s->f);
 29690       s->face = FACE_FROM_ID_OR_NULL (s->f, hlinfo->mouse_face_face_id);
 29691       if (!s->face)
 29692         s->face = FACE_FROM_ID (s->f, MOUSE_FACE_ID);
 29693 
 29694       s->face = FACE_FROM_ID (s->f, FACE_FOR_CHAR (s->f, s->face, c, -1, Qnil));
 29695       prepare_face_for_display (s->f, s->face);
 29696     }
 29697 
 29698   /* All glyph strings for the same composition has the same width,
 29699      i.e. the width set for the first component of the composition.  */
 29700   s->width = s->first_glyph->pixel_width;
 29701 
 29702   /* If the specified font could not be loaded, use the frame's
 29703      default font, but record the fact that we couldn't load it in
 29704      the glyph string so that we can draw rectangles for the
 29705      characters of the glyph string.  */
 29706   if (s->font == NULL)
 29707     {
 29708       s->font_not_found_p = true;
 29709       s->font = FRAME_FONT (s->f);
 29710     }
 29711 
 29712   /* Adjust base line for subscript/superscript text.  */
 29713   s->ybase += s->first_glyph->voffset;
 29714 
 29715   return s->cmp_to;
 29716 }
 29717 
 29718 static int
 29719 fill_gstring_glyph_string (struct glyph_string *s, int face_id,
 29720                            int start, int end, int overlaps)
 29721 {
 29722   struct glyph *glyph, *last;
 29723   int voffset;
 29724   Lisp_Object lgstring;
 29725   int i;
 29726   bool glyph_not_available_p;
 29727 
 29728   s->for_overlaps = overlaps;
 29729   glyph = s->row->glyphs[s->area] + start;
 29730   last = s->row->glyphs[s->area] + end;
 29731   voffset = glyph->voffset;
 29732   glyph_not_available_p = glyph->glyph_not_available_p;
 29733   s->cmp_id = glyph->u.cmp.id;
 29734   s->cmp_from = glyph->slice.cmp.from;
 29735   s->cmp_to = glyph->slice.cmp.to + 1;
 29736   if (s->hl == DRAW_MOUSE_FACE
 29737       || (s->hl == DRAW_CURSOR
 29738           && MATRIX_ROW (s->w->current_matrix,
 29739                          s->w->phys_cursor.vpos)->mouse_face_p
 29740           && cursor_in_mouse_face_p (s->w)))
 29741     {
 29742       Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (s->f);
 29743       s->face = FACE_FROM_ID_OR_NULL (s->f, hlinfo->mouse_face_face_id);
 29744       if (!s->face)
 29745         s->face = FACE_FROM_ID (s->f, MOUSE_FACE_ID);
 29746       prepare_face_for_display (s->f, s->face);
 29747     }
 29748   else
 29749     s->face = FACE_FROM_ID (s->f, face_id);
 29750   lgstring = composition_gstring_from_id (s->cmp_id);
 29751   s->font = XFONT_OBJECT (LGSTRING_FONT (lgstring));
 29752   /* The width of a composition glyph string is the sum of the
 29753      composition's glyph widths.  */
 29754   s->width = s->first_glyph->pixel_width;
 29755   glyph++;
 29756   while (glyph < last
 29757          && glyph->u.cmp.automatic
 29758          && glyph->u.cmp.id == s->cmp_id
 29759          && glyph->face_id == face_id
 29760          && s->cmp_to == glyph->slice.cmp.from
 29761          && glyph->glyph_not_available_p == glyph_not_available_p)
 29762     {
 29763       s->width += glyph->pixel_width;
 29764       s->cmp_to = (glyph++)->slice.cmp.to + 1;
 29765     }
 29766 
 29767   for (i = s->cmp_from; i < s->cmp_to; i++)
 29768     {
 29769       Lisp_Object lglyph = LGSTRING_GLYPH (lgstring, i);
 29770       unsigned code = LGLYPH_CODE (lglyph);
 29771 
 29772       /* Ensure that the code is only 2 bytes wide.  */
 29773       s->char2b[i] = code & 0xFFFF;
 29774     }
 29775 
 29776   /* If the specified font could not be loaded, record that fact in
 29777      S->font_not_found_p so that we can draw rectangles for the
 29778      characters of the glyph string.  */
 29779   if (glyph_not_available_p)
 29780     s->font_not_found_p = true;
 29781 
 29782   /* Adjust base line for subscript/superscript text.  */
 29783   s->ybase += voffset;
 29784 
 29785   return glyph - s->row->glyphs[s->area];
 29786 }
 29787 
 29788 
 29789 /* Fill glyph string S from a sequence glyphs for glyphless characters.
 29790    See the comment of fill_glyph_string for arguments.
 29791    Value is the index of the first glyph not in S.  */
 29792 
 29793 
 29794 static int
 29795 fill_glyphless_glyph_string (struct glyph_string *s, int face_id,
 29796                              int start, int end, int overlaps)
 29797 {
 29798   struct glyph *glyph, *last;
 29799   int voffset;
 29800 
 29801   eassert (s->first_glyph->type == GLYPHLESS_GLYPH);
 29802   s->for_overlaps = overlaps;
 29803   glyph = s->row->glyphs[s->area] + start;
 29804   last = s->row->glyphs[s->area] + end;
 29805   voffset = glyph->voffset;
 29806   s->face = FACE_FROM_ID (s->f, face_id);
 29807   s->font = s->face->font ? s->face->font : FRAME_FONT (s->f);
 29808   if (s->hl == DRAW_MOUSE_FACE
 29809       || (s->hl == DRAW_CURSOR
 29810           && MATRIX_ROW (s->w->current_matrix,
 29811                          s->w->phys_cursor.vpos)->mouse_face_p
 29812           && cursor_in_mouse_face_p (s->w)))
 29813     {
 29814       Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (s->f);
 29815       s->face = FACE_FROM_ID_OR_NULL (s->f, hlinfo->mouse_face_face_id);
 29816       if (!s->face)
 29817         s->face = FACE_FROM_ID (s->f, MOUSE_FACE_ID);
 29818       prepare_face_for_display (s->f, s->face);
 29819     }
 29820   s->nchars = 1;
 29821   s->width = glyph->pixel_width;
 29822   glyph++;
 29823   while (glyph < last
 29824          && glyph->type == GLYPHLESS_GLYPH
 29825          && glyph->voffset == voffset
 29826          && glyph->face_id == face_id)
 29827     {
 29828       s->nchars++;
 29829       s->width += glyph->pixel_width;
 29830       glyph++;
 29831     }
 29832   s->ybase += voffset;
 29833   return glyph - s->row->glyphs[s->area];
 29834 }
 29835 
 29836 
 29837 /* Fill glyph string S from a sequence of character glyphs.
 29838 
 29839    FACE_ID is the face id of the string.  START is the index of the
 29840    first glyph to consider, END is the index of the last + 1.
 29841    OVERLAPS non-zero means S should draw the foreground only, and use
 29842    its physical height for clipping.  See also draw_glyphs.
 29843 
 29844    Value is the index of the first glyph not in S.  */
 29845 
 29846 static int
 29847 fill_glyph_string (struct glyph_string *s, int face_id,
 29848                    int start, int end, int overlaps)
 29849 {
 29850   struct glyph *glyph, *last;
 29851   int voffset;
 29852   bool glyph_not_available_p;
 29853 
 29854   eassert (s->f == XFRAME (s->w->frame));
 29855   eassert (s->nchars == 0);
 29856   eassert (start >= 0 && end > start);
 29857 
 29858   s->for_overlaps = overlaps;
 29859   glyph = s->row->glyphs[s->area] + start;
 29860   last = s->row->glyphs[s->area] + end;
 29861   voffset = glyph->voffset;
 29862   s->padding_p = glyph->padding_p;
 29863   glyph_not_available_p = glyph->glyph_not_available_p;
 29864 
 29865   while (glyph < last
 29866          && glyph->type == CHAR_GLYPH
 29867          && glyph->voffset == voffset
 29868          /* Same face id implies same font, nowadays.  */
 29869          && glyph->face_id == face_id
 29870          && glyph->glyph_not_available_p == glyph_not_available_p)
 29871     {
 29872       s->face = get_glyph_face_and_encoding (s->f, glyph,
 29873                                              s->char2b + s->nchars);
 29874       ++s->nchars;
 29875       eassert (s->nchars <= end - start);
 29876       s->width += glyph->pixel_width;
 29877       if (glyph++->padding_p != s->padding_p)
 29878         break;
 29879     }
 29880 
 29881   s->font = s->face->font;
 29882 
 29883   if (s->hl == DRAW_MOUSE_FACE
 29884       || (s->hl == DRAW_CURSOR
 29885           && MATRIX_ROW (s->w->current_matrix,
 29886                          s->w->phys_cursor.vpos)->mouse_face_p
 29887           && cursor_in_mouse_face_p (s->w)))
 29888     {
 29889       Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (s->f);
 29890       s->face = FACE_FROM_ID_OR_NULL (s->f, hlinfo->mouse_face_face_id);
 29891       if (!s->face)
 29892         s->face = FACE_FROM_ID (s->f, MOUSE_FACE_ID);
 29893       s->face
 29894         = FACE_FROM_ID (s->f, FACE_FOR_CHAR (s->f, s->face,
 29895                                              s->first_glyph->u.ch, -1, Qnil));
 29896       prepare_face_for_display (s->f, s->face);
 29897     }
 29898 
 29899   /* If the specified font could not be loaded, use the frame's font,
 29900      but record the fact that we couldn't load it in
 29901      S->font_not_found_p so that we can draw rectangles for the
 29902      characters of the glyph string.  */
 29903   if (s->font == NULL || glyph_not_available_p)
 29904     {
 29905       s->font_not_found_p = true;
 29906       s->font = FRAME_FONT (s->f);
 29907     }
 29908 
 29909   /* Adjust base line for subscript/superscript text.  */
 29910   s->ybase += voffset;
 29911 
 29912   eassert (s->face && s->face->gc);
 29913   return glyph - s->row->glyphs[s->area];
 29914 }
 29915 
 29916 
 29917 /* Fill glyph string S from image glyph S->first_glyph.  */
 29918 
 29919 static void
 29920 fill_image_glyph_string (struct glyph_string *s)
 29921 {
 29922   eassert (s->first_glyph->type == IMAGE_GLYPH);
 29923   s->img = IMAGE_FROM_ID (s->f, s->first_glyph->u.img_id);
 29924   eassert (s->img);
 29925   s->slice = s->first_glyph->slice.img;
 29926   s->face = FACE_FROM_ID (s->f, s->first_glyph->face_id);
 29927   s->font = s->face->font;
 29928   if (s->hl == DRAW_MOUSE_FACE
 29929       || (s->hl == DRAW_CURSOR
 29930           && MATRIX_ROW (s->w->current_matrix,
 29931                          s->w->phys_cursor.vpos)->mouse_face_p
 29932           && cursor_in_mouse_face_p (s->w)))
 29933     {
 29934       Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (s->f);
 29935       s->face = FACE_FROM_ID_OR_NULL (s->f, hlinfo->mouse_face_face_id);
 29936       if (!s->face)
 29937         s->face = FACE_FROM_ID (s->f, MOUSE_FACE_ID);
 29938       prepare_face_for_display (s->f, s->face);
 29939     }
 29940   s->width = s->first_glyph->pixel_width;
 29941 
 29942   /* Adjust base line for subscript/superscript text.  */
 29943   s->ybase += s->first_glyph->voffset;
 29944 }
 29945 
 29946 
 29947 #ifdef HAVE_XWIDGETS
 29948 static void
 29949 fill_xwidget_glyph_string (struct glyph_string *s)
 29950 {
 29951   eassert (s->first_glyph->type == XWIDGET_GLYPH);
 29952   s->face = FACE_FROM_ID (s->f, s->first_glyph->face_id);
 29953   s->font = s->face->font;
 29954   if (s->hl == DRAW_MOUSE_FACE
 29955       || (s->hl == DRAW_CURSOR
 29956           && MATRIX_ROW (s->w->current_matrix,
 29957                          s->w->phys_cursor.vpos)->mouse_face_p
 29958           && cursor_in_mouse_face_p (s->w)))
 29959     {
 29960       Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (s->f);
 29961       s->face = FACE_FROM_ID_OR_NULL (s->f, hlinfo->mouse_face_face_id);
 29962       if (!s->face)
 29963         s->face = FACE_FROM_ID (s->f, MOUSE_FACE_ID);
 29964       prepare_face_for_display (s->f, s->face);
 29965     }
 29966   s->width = s->first_glyph->pixel_width;
 29967   s->ybase += s->first_glyph->voffset;
 29968   s->xwidget = xwidget_from_id (s->first_glyph->u.xwidget);
 29969 }
 29970 #endif
 29971 /* Fill glyph string S from a sequence of stretch glyphs.
 29972 
 29973    START is the index of the first glyph to consider,
 29974    END is the index of the last + 1.
 29975 
 29976    Value is the index of the first glyph not in S.  */
 29977 
 29978 static int
 29979 fill_stretch_glyph_string (struct glyph_string *s, int start, int end)
 29980 {
 29981   struct glyph *glyph, *last;
 29982   int voffset, face_id;
 29983 
 29984   eassert (s->first_glyph->type == STRETCH_GLYPH);
 29985 
 29986   glyph = s->row->glyphs[s->area] + start;
 29987   last = s->row->glyphs[s->area] + end;
 29988   face_id = glyph->face_id;
 29989   s->face = FACE_FROM_ID (s->f, face_id);
 29990   s->font = s->face->font;
 29991   if (s->hl == DRAW_MOUSE_FACE
 29992       || (s->hl == DRAW_CURSOR
 29993           && MATRIX_ROW (s->w->current_matrix,
 29994                          s->w->phys_cursor.vpos)->mouse_face_p
 29995           && cursor_in_mouse_face_p (s->w)))
 29996     {
 29997       Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (s->f);
 29998       s->face = FACE_FROM_ID_OR_NULL (s->f, hlinfo->mouse_face_face_id);
 29999       if (!s->face)
 30000         s->face = FACE_FROM_ID (s->f, MOUSE_FACE_ID);
 30001       prepare_face_for_display (s->f, s->face);
 30002     }
 30003   s->width = glyph->pixel_width;
 30004   s->nchars = 1;
 30005   voffset = glyph->voffset;
 30006 
 30007   for (++glyph;
 30008        (glyph < last
 30009         && glyph->type == STRETCH_GLYPH
 30010         && glyph->voffset == voffset
 30011         && glyph->face_id == face_id);
 30012        ++glyph)
 30013     s->width += glyph->pixel_width;
 30014 
 30015   /* Adjust base line for subscript/superscript text.  */
 30016   s->ybase += voffset;
 30017 
 30018   /* The case that face->gc == 0 is handled when drawing the glyph
 30019      string by calling prepare_face_for_display.  */
 30020   eassert (s->face);
 30021   return glyph - s->row->glyphs[s->area];
 30022 }
 30023 
 30024 static struct font_metrics *
 30025 get_per_char_metric (struct font *font, const unsigned *char2b)
 30026 {
 30027   static struct font_metrics metrics;
 30028 
 30029   if (! font)
 30030     return NULL;
 30031   if (*char2b == FONT_INVALID_CODE)
 30032     return NULL;
 30033 
 30034   font->driver->text_extents (font, char2b, 1, &metrics);
 30035   return &metrics;
 30036 }
 30037 
 30038 /* A subroutine that computes "normal" values of ASCENT and DESCENT
 30039    for FONT.  Values are taken from font-global ones, except for fonts
 30040    that claim preposterously large values, but whose glyphs actually
 30041    have reasonable dimensions.  C is the character to use for metrics
 30042    if the font-global values are too large; if C is negative, the
 30043    function selects a default character.  */
 30044 static void
 30045 normal_char_ascent_descent (struct font *font, int c, int *ascent, int *descent)
 30046 {
 30047   *ascent = FONT_BASE (font);
 30048   *descent = FONT_DESCENT (font);
 30049 
 30050   if (FONT_TOO_HIGH (font))
 30051     {
 30052       unsigned char2b;
 30053 
 30054       /* Get metrics of C, defaulting to a reasonably sized ASCII
 30055          character.  */
 30056       if (get_char_glyph_code (c >= 0 ? c : '{', font, &char2b))
 30057         {
 30058           struct font_metrics *pcm = get_per_char_metric (font, &char2b);
 30059           eassume (pcm);
 30060 
 30061           if (!(pcm->width == 0 && pcm->rbearing == 0 && pcm->lbearing == 0))
 30062             {
 30063               /* We add 1 pixel to character dimensions as heuristics
 30064                  that produces nicer display, e.g. when the face has
 30065                  the box attribute.  */
 30066               *ascent = pcm->ascent + 1;
 30067               *descent = pcm->descent + 1;
 30068             }
 30069         }
 30070     }
 30071 }
 30072 
 30073 /* A subroutine that computes a reasonable "normal character height"
 30074    for fonts that claim preposterously large vertical dimensions, but
 30075    whose glyphs are actually reasonably sized.  C is the character
 30076    whose metrics to use for those fonts, or -1 for default
 30077    character.  */
 30078 static int
 30079 normal_char_height (struct font *font, int c)
 30080 {
 30081   int ascent, descent;
 30082 
 30083   normal_char_ascent_descent (font, c, &ascent, &descent);
 30084 
 30085   return ascent + descent;
 30086 }
 30087 
 30088 /* EXPORT for RIF:
 30089    Set *LEFT and *RIGHT to the left and right overhang of GLYPH on
 30090    frame F.  Overhangs of glyphs other than type CHAR_GLYPH are
 30091    assumed to be zero.  */
 30092 
 30093 void
 30094 gui_get_glyph_overhangs (struct glyph *glyph, struct frame *f, int *left, int *right)
 30095 {
 30096   *left = *right = 0;
 30097 
 30098   if (glyph->type == CHAR_GLYPH)
 30099     {
 30100       unsigned char2b;
 30101       struct face *face = get_glyph_face_and_encoding (f, glyph, &char2b);
 30102       if (face->font)
 30103         {
 30104           struct font_metrics *pcm = get_per_char_metric (face->font, &char2b);
 30105           if (pcm)
 30106             {
 30107               if (pcm->rbearing > pcm->width)
 30108                 *right = pcm->rbearing - pcm->width;
 30109               if (pcm->lbearing < 0)
 30110                 *left = -pcm->lbearing;
 30111             }
 30112         }
 30113     }
 30114   else if (glyph->type == COMPOSITE_GLYPH)
 30115     {
 30116       if (! glyph->u.cmp.automatic)
 30117         {
 30118           struct composition *cmp = composition_table[glyph->u.cmp.id];
 30119 
 30120           if (cmp->rbearing > cmp->pixel_width)
 30121             *right = cmp->rbearing - cmp->pixel_width;
 30122           if (cmp->lbearing < 0)
 30123             *left = - cmp->lbearing;
 30124         }
 30125       else
 30126         {
 30127           Lisp_Object gstring = composition_gstring_from_id (glyph->u.cmp.id);
 30128           struct font_metrics metrics;
 30129 
 30130           composition_gstring_width (gstring, glyph->slice.cmp.from,
 30131                                      glyph->slice.cmp.to + 1, &metrics);
 30132           if (metrics.rbearing > metrics.width)
 30133             *right = metrics.rbearing - metrics.width;
 30134           if (metrics.lbearing < 0)
 30135             *left = - metrics.lbearing;
 30136         }
 30137     }
 30138 }
 30139 
 30140 
 30141 /* Return the index of the first glyph preceding glyph string S that
 30142    is overwritten by S because of S's left overhang.  Value is -1
 30143    if no glyphs are overwritten.  */
 30144 
 30145 static int
 30146 left_overwritten (struct glyph_string *s)
 30147 {
 30148   int k;
 30149 
 30150   if (s->left_overhang)
 30151     {
 30152       int x = 0, i;
 30153       struct glyph *glyphs = s->row->glyphs[s->area];
 30154       int first = s->first_glyph - glyphs;
 30155 
 30156       for (i = first - 1; i >= 0 && x > -s->left_overhang; --i)
 30157         x -= glyphs[i].pixel_width;
 30158 
 30159       k = i + 1;
 30160     }
 30161   else
 30162     k = -1;
 30163 
 30164   return k;
 30165 }
 30166 
 30167 
 30168 /* Return the index of the first glyph preceding glyph string S that
 30169    is overwriting S because of its right overhang.  Value is -1 if no
 30170    glyph in front of S overwrites S.  */
 30171 
 30172 static int
 30173 left_overwriting (struct glyph_string *s)
 30174 {
 30175   int i, k, x;
 30176   struct glyph *glyphs = s->row->glyphs[s->area];
 30177   int first = s->first_glyph - glyphs;
 30178 
 30179   k = -1;
 30180   x = 0;
 30181   for (i = first - 1; i >= 0; --i)
 30182     {
 30183       int left, right;
 30184       gui_get_glyph_overhangs (glyphs + i, s->f, &left, &right);
 30185       if (x + right > 0)
 30186         k = i;
 30187       x -= glyphs[i].pixel_width;
 30188     }
 30189 
 30190   return k;
 30191 }
 30192 
 30193 
 30194 /* Return the index of the last glyph following glyph string S that is
 30195    overwritten by S because of S's right overhang.  Value is -1 if
 30196    no such glyph is found.  */
 30197 
 30198 static int
 30199 right_overwritten (struct glyph_string *s)
 30200 {
 30201   int k = -1;
 30202 
 30203   if (s->right_overhang)
 30204     {
 30205       int x = 0, i;
 30206       struct glyph *glyphs = s->row->glyphs[s->area];
 30207       int first = (s->first_glyph - glyphs
 30208                    + (s->first_glyph->type == COMPOSITE_GLYPH ? 1 : s->nchars));
 30209       int end = s->row->used[s->area];
 30210 
 30211       for (i = first; i < end && s->right_overhang > x; ++i)
 30212         x += glyphs[i].pixel_width;
 30213 
 30214       k = i;
 30215     }
 30216 
 30217   return k;
 30218 }
 30219 
 30220 
 30221 /* Return the index of the last glyph following glyph string S that
 30222    overwrites S because of its left overhang.  Value is negative
 30223    if no such glyph is found.  */
 30224 
 30225 static int
 30226 right_overwriting (struct glyph_string *s)
 30227 {
 30228   int i, k, x;
 30229   int end = s->row->used[s->area];
 30230   struct glyph *glyphs = s->row->glyphs[s->area];
 30231   int first = (s->first_glyph - glyphs
 30232                + (s->first_glyph->type == COMPOSITE_GLYPH ? 1 : s->nchars));
 30233 
 30234   k = -1;
 30235   x = 0;
 30236   for (i = first; i < end; ++i)
 30237     {
 30238       int left, right;
 30239       gui_get_glyph_overhangs (glyphs + i, s->f, &left, &right);
 30240       if (x - left < 0)
 30241         k = i;
 30242       x += glyphs[i].pixel_width;
 30243     }
 30244 
 30245   return k;
 30246 }
 30247 
 30248 
 30249 /* Set background width of glyph string S.  START is the index of the
 30250    first glyph following S.  LAST_X is the right-most x-position + 1
 30251    in the drawing area.
 30252 
 30253    If S->hl is DRAW_CURSOR, S->f is a window system frame, and the
 30254    cursor in S's window is currently inside mouse face, also update
 30255    S->width to take into account potentially differing :box
 30256    properties between the original face and the mouse face.  */
 30257 
 30258 static void
 30259 set_glyph_string_background_width (struct glyph_string *s, int start, int last_x)
 30260 {
 30261   /* If the face of this glyph string has to be drawn to the end of
 30262      the drawing area, set S->extends_to_end_of_line_p.  */
 30263 
 30264   if (start == s->row->used[s->area]
 30265       && ((s->row->fill_line_p
 30266            && (s->hl == DRAW_NORMAL_TEXT
 30267                || s->hl == DRAW_IMAGE_RAISED
 30268                || s->hl == DRAW_IMAGE_SUNKEN))
 30269           || s->hl == DRAW_MOUSE_FACE))
 30270     s->extends_to_end_of_line_p = true;
 30271 
 30272   /* If S extends its face to the end of the line, set its
 30273      background_width to the distance to the right edge of the drawing
 30274      area.  */
 30275   if (s->extends_to_end_of_line_p)
 30276     s->background_width = last_x - s->x + 1;
 30277   else
 30278     {
 30279       s->background_width = s->width;
 30280 #ifdef HAVE_WINDOW_SYSTEM
 30281       if (FRAME_WINDOW_P (s->f)
 30282           && s->hl == DRAW_CURSOR
 30283           && MATRIX_ROW (s->w->current_matrix,
 30284                          s->w->phys_cursor.vpos)->mouse_face_p
 30285           && cursor_in_mouse_face_p (s->w))
 30286         {
 30287           /* Adjust the background width of the glyph string, because
 30288              if the glyph's face has the :box attribute, its
 30289              pixel_width might be different when it's displayed in the
 30290              mouse-face, if that also has the :box attribute.  */
 30291           struct glyph *g = s->first_glyph;
 30292           struct face *regular_face = FACE_FROM_ID (s->f, g->face_id);
 30293           s->background_width +=
 30294             adjust_glyph_width_for_mouse_face (g, s->row, s->w,
 30295                                                regular_face, s->face);
 30296           /* S->width is probably worth adjusting here as well.  */
 30297           s->width = s->background_width;
 30298         }
 30299 #endif
 30300     }
 30301 }
 30302 
 30303 
 30304 /* Return glyph string that shares background with glyph string S and
 30305    whose `background_width' member has been set.  */
 30306 
 30307 static struct glyph_string *
 30308 glyph_string_containing_background_width (struct glyph_string *s)
 30309 {
 30310   if (s->cmp)
 30311     while (s->cmp_from)
 30312       s = s->prev;
 30313 
 30314   return s;
 30315 }
 30316 
 30317 
 30318 /* Compute overhangs and x-positions for glyph string S and its
 30319    predecessors, or successors.  X is the starting x-position for S.
 30320    BACKWARD_P means process predecessors.  */
 30321 
 30322 static void
 30323 compute_overhangs_and_x (struct glyph_string *s, int x, bool backward_p)
 30324 {
 30325   if (backward_p)
 30326     {
 30327       while (s)
 30328         {
 30329           if (FRAME_RIF (s->f)->compute_glyph_string_overhangs)
 30330             FRAME_RIF (s->f)->compute_glyph_string_overhangs (s);
 30331           if (!s->cmp || s->cmp_to == s->cmp->glyph_len)
 30332             x -= s->width;
 30333           s->x = x;
 30334           s = s->prev;
 30335         }
 30336     }
 30337   else
 30338     {
 30339       while (s)
 30340         {
 30341           if (FRAME_RIF (s->f)->compute_glyph_string_overhangs)
 30342             FRAME_RIF (s->f)->compute_glyph_string_overhangs (s);
 30343           s->x = x;
 30344           if (!s->cmp || s->cmp_to == s->cmp->glyph_len)
 30345             x += s->width;
 30346           s = s->next;
 30347         }
 30348     }
 30349 }
 30350 
 30351 
 30352 
 30353 /* The following macros are only called from draw_glyphs below.
 30354    They reference the following parameters of that function directly:
 30355      `w', `row', `area', and `overlap_p'
 30356    as well as the following local variables:
 30357      `s', `f', and `hdc' (in W32)  */
 30358 
 30359 #ifdef HAVE_NTGUI
 30360 /* On W32, silently add local `hdc' variable to argument list of
 30361    init_glyph_string.  */
 30362 #define INIT_GLYPH_STRING(s, char2b, w, row, area, start, hl) \
 30363   init_glyph_string (s, hdc, char2b, w, row, area, start, hl)
 30364 #else
 30365 #define INIT_GLYPH_STRING(s, char2b, w, row, area, start, hl) \
 30366   init_glyph_string (s, char2b, w, row, area, start, hl)
 30367 #endif
 30368 
 30369 /* Add a glyph string for a stretch glyph to the list of strings
 30370    between HEAD and TAIL.  START is the index of the stretch glyph in
 30371    row area AREA of glyph row ROW.  END is the index of the last glyph
 30372    in that glyph row area.  X is the current output position assigned
 30373    to the new glyph string constructed.  HL overrides that face of the
 30374    glyph; e.g. it is DRAW_CURSOR if a cursor has to be drawn.  LAST_X
 30375    is the right-most x-position of the drawing area.  */
 30376 
 30377 /* SunOS 4 bundled cc, barfed on continuations in the arg lists here
 30378    and below -- keep them on one line.  */
 30379 #define BUILD_STRETCH_GLYPH_STRING(START, END, HEAD, TAIL, HL, X, LAST_X)   \
 30380      do                                                                     \
 30381        {                                                                    \
 30382          s = alloca (sizeof *s);                                            \
 30383          INIT_GLYPH_STRING (s, NULL, w, row, area, START, HL);              \
 30384          START = fill_stretch_glyph_string (s, START, END);                 \
 30385          append_glyph_string (&HEAD, &TAIL, s);                             \
 30386          s->x = (X);                                                        \
 30387        }                                                                    \
 30388      while (false)
 30389 
 30390 
 30391 /* Add a glyph string for an image glyph to the list of strings
 30392    between HEAD and TAIL.  START is the index of the image glyph in
 30393    row area AREA of glyph row ROW.  END is the index of the last glyph
 30394    in that glyph row area.  X is the current output position assigned
 30395    to the new glyph string constructed.  HL overrides that face of the
 30396    glyph; e.g. it is DRAW_CURSOR if a cursor has to be drawn.  LAST_X
 30397    is the right-most x-position of the drawing area.  */
 30398 
 30399 #define BUILD_IMAGE_GLYPH_STRING(START, END, HEAD, TAIL, HL, X, LAST_X) \
 30400      do                                                                 \
 30401        {                                                                \
 30402          s = alloca (sizeof *s);                                        \
 30403          INIT_GLYPH_STRING (s, NULL, w, row, area, START, HL);          \
 30404          fill_image_glyph_string (s);                                   \
 30405          append_glyph_string (&HEAD, &TAIL, s);                         \
 30406          ++START;                                                       \
 30407          s->x = (X);                                                    \
 30408        }                                                                \
 30409      while (false)
 30410 
 30411 #ifndef HAVE_XWIDGETS
 30412 # define BUILD_XWIDGET_GLYPH_STRING(START, END, HEAD, TAIL, HL, X, LAST_X) \
 30413      eassume (false)
 30414 #else
 30415 # define BUILD_XWIDGET_GLYPH_STRING(START, END, HEAD, TAIL, HL, X, LAST_X) \
 30416      do                                                                 \
 30417        {                                                                \
 30418          s = alloca (sizeof *s);                                        \
 30419          INIT_GLYPH_STRING (s, NULL, w, row, area, START, HL);          \
 30420          fill_xwidget_glyph_string (s);                                 \
 30421          append_glyph_string (&(HEAD), &(TAIL), s);                     \
 30422          ++(START);                                                     \
 30423          s->x = (X);                                                    \
 30424        }                                                                \
 30425      while (false)
 30426 #endif
 30427 
 30428 /* Add a glyph string for a sequence of character glyphs to the list
 30429    of strings between HEAD and TAIL.  START is the index of the first
 30430    glyph in row area AREA of glyph row ROW that is part of the new
 30431    glyph string.  END is the index of the last glyph in that glyph row
 30432    area.  X is the current output position assigned to the new glyph
 30433    string constructed.  HL overrides that face of the glyph; e.g. it
 30434    is DRAW_CURSOR if a cursor has to be drawn.  LAST_X is the
 30435    right-most x-position of the drawing area.  */
 30436 
 30437 #define BUILD_CHAR_GLYPH_STRINGS(START, END, HEAD, TAIL, HL, X, LAST_X)    \
 30438      do                                                                    \
 30439        {                                                                   \
 30440          int face_id;                                                      \
 30441          unsigned *char2b;                                         \
 30442                                                                            \
 30443          face_id = (row)->glyphs[area][START].face_id;                     \
 30444                                                                            \
 30445          s = alloca (sizeof *s);                                           \
 30446          SAFE_NALLOCA (char2b, 1, (END) - (START));                        \
 30447          INIT_GLYPH_STRING (s, char2b, w, row, area, START, HL);           \
 30448          append_glyph_string (&HEAD, &TAIL, s);                            \
 30449          s->x = (X);                                                       \
 30450          START = fill_glyph_string (s, face_id, START, END, overlaps);     \
 30451        }                                                                   \
 30452      while (false)
 30453 
 30454 
 30455 /* Add a glyph string for a composite sequence to the list of strings
 30456    between HEAD and TAIL.  START is the index of the first glyph in
 30457    row area AREA of glyph row ROW that is part of the new glyph
 30458    string.  END is the index of the last glyph in that glyph row area.
 30459    X is the current output position assigned to the new glyph string
 30460    constructed.  HL overrides that face of the glyph; e.g. it is
 30461    DRAW_CURSOR if a cursor has to be drawn.  LAST_X is the right-most
 30462    x-position of the drawing area.  */
 30463 
 30464 #define BUILD_COMPOSITE_GLYPH_STRING(START, END, HEAD, TAIL, HL, X, LAST_X) \
 30465   do {                                                                      \
 30466     int face_id = (row)->glyphs[area][START].face_id;                       \
 30467     struct face *base_face = FACE_FROM_ID (f, face_id);             \
 30468     ptrdiff_t cmp_id = (row)->glyphs[area][START].u.cmp.id;                 \
 30469     struct composition *cmp = composition_table[cmp_id];                    \
 30470     unsigned *char2b;                                                       \
 30471     struct glyph_string *first_s = NULL;                                    \
 30472     int n;                                                                  \
 30473                                                                             \
 30474     SAFE_NALLOCA (char2b, 1, cmp->glyph_len);                               \
 30475                                                                             \
 30476     /* Make glyph_strings for each glyph sequence that is drawable by       \
 30477        the same face, and append them to HEAD/TAIL.  */                     \
 30478     for (n = 0; n < cmp->glyph_len;)                                        \
 30479       {                                                                     \
 30480         s = alloca (sizeof *s);                                             \
 30481         INIT_GLYPH_STRING (s, char2b, w, row, area, START, HL);             \
 30482         append_glyph_string (&(HEAD), &(TAIL), s);                          \
 30483         s->cmp = cmp;                                                       \
 30484         s->cmp_from = n;                                                    \
 30485         s->x = (X);                                                         \
 30486         if (n == 0)                                                         \
 30487           first_s = s;                                                      \
 30488         n = fill_composite_glyph_string (s, base_face, overlaps);           \
 30489       }                                                                     \
 30490                                                                             \
 30491     ++START;                                                                \
 30492     s = first_s;                                                            \
 30493   } while (false)
 30494 
 30495 
 30496 /* Add a glyph string for a glyph-string sequence to the list of strings
 30497    between HEAD and TAIL.  */
 30498 
 30499 #define BUILD_GSTRING_GLYPH_STRING(START, END, HEAD, TAIL, HL, X, LAST_X) \
 30500   do {                                                                    \
 30501     int face_id;                                                          \
 30502     unsigned *char2b;                                                     \
 30503     Lisp_Object gstring;                                                  \
 30504                                                                           \
 30505     face_id = (row)->glyphs[area][START].face_id;                         \
 30506     gstring = (composition_gstring_from_id                                \
 30507                ((row)->glyphs[area][START].u.cmp.id));                    \
 30508     s = alloca (sizeof *s);                                               \
 30509     SAFE_NALLOCA (char2b, 1, LGSTRING_GLYPH_LEN (gstring));               \
 30510     INIT_GLYPH_STRING (s, char2b, w, row, area, START, HL);               \
 30511     append_glyph_string (&(HEAD), &(TAIL), s);                            \
 30512     s->x = (X);                                                           \
 30513     START = fill_gstring_glyph_string (s, face_id, START, END, overlaps); \
 30514   } while (false)
 30515 
 30516 
 30517 /* Add a glyph string for a sequence of glyphless character's glyphs
 30518    to the list of strings between HEAD and TAIL.  The meanings of
 30519    arguments are the same as those of BUILD_CHAR_GLYPH_STRINGS.  */
 30520 
 30521 #define BUILD_GLYPHLESS_GLYPH_STRING(START, END, HEAD, TAIL, HL, X, LAST_X) \
 30522   do                                                                        \
 30523     {                                                                       \
 30524       int face_id;                                                          \
 30525                                                                             \
 30526       face_id = (row)->glyphs[area][START].face_id;                         \
 30527                                                                             \
 30528       s = alloca (sizeof *s);                                               \
 30529       INIT_GLYPH_STRING (s, NULL, w, row, area, START, HL);                 \
 30530       append_glyph_string (&HEAD, &TAIL, s);                                \
 30531       s->x = (X);                                                           \
 30532       START = fill_glyphless_glyph_string (s, face_id, START, END,          \
 30533                                            overlaps);                       \
 30534     }                                                                       \
 30535   while (false)
 30536 
 30537 
 30538 /* Build a list of glyph strings between HEAD and TAIL for the glyphs
 30539    of AREA of glyph row ROW on window W between indices START and END.
 30540    HL overrides the face for drawing glyph strings, e.g. it is
 30541    DRAW_CURSOR to draw a cursor.  X and LAST_X are start and end
 30542    x-positions of the drawing area.
 30543 
 30544    This is an ugly monster macro construct because we must use alloca
 30545    to allocate glyph strings (because draw_glyphs can be called
 30546    asynchronously).  */
 30547 
 30548 #define BUILD_GLYPH_STRINGS_1(START, END, HEAD, TAIL, HL, X, LAST_X)    \
 30549   do                                                                    \
 30550     {                                                                   \
 30551       HEAD = TAIL = NULL;                                               \
 30552       while (START < END)                                               \
 30553         {                                                               \
 30554           struct glyph *first_glyph = (row)->glyphs[area] + START;      \
 30555           switch (first_glyph->type)                                    \
 30556             {                                                           \
 30557             case CHAR_GLYPH:                                            \
 30558               BUILD_CHAR_GLYPH_STRINGS (START, END, HEAD, TAIL,         \
 30559                                         HL, X, LAST_X);                 \
 30560               break;                                                    \
 30561                                                                         \
 30562             case COMPOSITE_GLYPH:                                       \
 30563               if (first_glyph->u.cmp.automatic)                         \
 30564                 BUILD_GSTRING_GLYPH_STRING (START, END, HEAD, TAIL,     \
 30565                                             HL, X, LAST_X);             \
 30566               else                                                      \
 30567                 BUILD_COMPOSITE_GLYPH_STRING (START, END, HEAD, TAIL,   \
 30568                                               HL, X, LAST_X);           \
 30569               break;                                                    \
 30570                                                                         \
 30571             case STRETCH_GLYPH:                                         \
 30572               BUILD_STRETCH_GLYPH_STRING (START, END, HEAD, TAIL,       \
 30573                                           HL, X, LAST_X);               \
 30574               break;                                                    \
 30575                                                                         \
 30576             case IMAGE_GLYPH:                                           \
 30577               BUILD_IMAGE_GLYPH_STRING (START, END, HEAD, TAIL,         \
 30578                                         HL, X, LAST_X);                 \
 30579               break;
 30580 
 30581 #define BUILD_GLYPH_STRINGS_XW(START, END, HEAD, TAIL, HL, X, LAST_X)   \
 30582             case XWIDGET_GLYPH:                                         \
 30583               BUILD_XWIDGET_GLYPH_STRING (START, END, HEAD, TAIL,       \
 30584                                           HL, X, LAST_X);               \
 30585               break;
 30586 
 30587 #define BUILD_GLYPH_STRINGS_2(START, END, HEAD, TAIL, HL, X, LAST_X)    \
 30588             case GLYPHLESS_GLYPH:                                       \
 30589               BUILD_GLYPHLESS_GLYPH_STRING (START, END, HEAD, TAIL,     \
 30590                                             HL, X, LAST_X);             \
 30591               break;                                                    \
 30592                                                                         \
 30593             default:                                                    \
 30594               emacs_abort ();                                           \
 30595             }                                                           \
 30596                                                                         \
 30597           if (s)                                                        \
 30598             {                                                           \
 30599               set_glyph_string_background_width (s, START, LAST_X);     \
 30600               (X) += s->width;                                          \
 30601             }                                                           \
 30602         }                                                               \
 30603     } while (false)
 30604 
 30605 
 30606 #define BUILD_GLYPH_STRINGS(START, END, HEAD, TAIL, HL, X, LAST_X)      \
 30607     BUILD_GLYPH_STRINGS_1(START, END, HEAD, TAIL, HL, X, LAST_X)        \
 30608     BUILD_GLYPH_STRINGS_XW(START, END, HEAD, TAIL, HL, X, LAST_X)       \
 30609     BUILD_GLYPH_STRINGS_2(START, END, HEAD, TAIL, HL, X, LAST_X)
 30610 
 30611 
 30612 /* Draw glyphs between START and END in AREA of ROW on window W,
 30613    starting at x-position X.  X is relative to AREA in W.  HL is a
 30614    face-override with the following meaning:
 30615 
 30616    DRAW_NORMAL_TEXT     draw normally
 30617    DRAW_CURSOR          draw in cursor face
 30618    DRAW_MOUSE_FACE      draw in mouse face.
 30619    DRAW_INVERSE_VIDEO   draw in mode line face
 30620    DRAW_IMAGE_SUNKEN    draw an image with a sunken relief around it
 30621    DRAW_IMAGE_RAISED    draw an image with a raised relief around it
 30622 
 30623    If OVERLAPS is non-zero, draw only the foreground of characters and
 30624    clip to the physical height of ROW.  Non-zero value also defines
 30625    the overlapping part to be drawn:
 30626 
 30627    OVERLAPS_PRED                overlap with preceding rows
 30628    OVERLAPS_SUCC                overlap with succeeding rows
 30629    OVERLAPS_BOTH                overlap with both preceding/succeeding rows
 30630    OVERLAPS_ERASED_CURSOR       overlap with erased cursor area
 30631 
 30632    Value is the x-position reached, relative to AREA of W.  */
 30633 
 30634 static int
 30635 draw_glyphs (struct window *w, int x, struct glyph_row *row,
 30636              enum glyph_row_area area, ptrdiff_t start, ptrdiff_t end,
 30637              enum draw_glyphs_face hl, int overlaps)
 30638 {
 30639   struct glyph_string *head, *tail;
 30640   struct glyph_string *s;
 30641   struct glyph_string *clip_head = NULL, *clip_tail = NULL;
 30642   int i, j, x_reached, last_x, area_left = 0;
 30643   struct frame *f = XFRAME (WINDOW_FRAME (w));
 30644 
 30645   ALLOCATE_HDC (hdc, f);
 30646 
 30647   /* Let's rather be paranoid than getting a SEGV.  */
 30648   end = min (end, row->used[area]);
 30649   start = clip_to_bounds (0, start, end);
 30650 
 30651   /* Translate X to frame coordinates.  Set last_x to the right
 30652      end of the drawing area.  */
 30653   if (row->full_width_p)
 30654     {
 30655       /* X is relative to the left edge of W, without scroll bars
 30656          or fringes.  */
 30657       area_left = WINDOW_LEFT_EDGE_X (w);
 30658       last_x = (WINDOW_LEFT_EDGE_X (w) + WINDOW_PIXEL_WIDTH (w)
 30659                 - (row->mode_line_p ? WINDOW_RIGHT_DIVIDER_WIDTH (w) : 0));
 30660     }
 30661   else
 30662     {
 30663       area_left = window_box_left (w, area);
 30664       last_x = area_left + window_box_width (w, area);
 30665     }
 30666   x += area_left;
 30667 
 30668   /* Build a doubly-linked list of glyph_string structures between
 30669      head and tail from what we have to draw.  Note that the macro
 30670      BUILD_GLYPH_STRINGS will modify its start parameter.  That's
 30671      the reason we use a separate variable `i'.  */
 30672   i = start;
 30673   USE_SAFE_ALLOCA;
 30674   BUILD_GLYPH_STRINGS (i, end, head, tail, hl, x, last_x);
 30675   if (tail)
 30676     {
 30677       s = glyph_string_containing_background_width (tail);
 30678       x_reached = s->x + s->background_width;
 30679     }
 30680   else
 30681     x_reached = x;
 30682 
 30683   /* If there are any glyphs with lbearing < 0 or rbearing > width in
 30684      the row, redraw some glyphs in front or following the glyph
 30685      strings built above.  */
 30686   if (head && !overlaps && row->contains_overlapping_glyphs_p)
 30687     {
 30688       struct glyph_string *h, *t;
 30689       Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (f);
 30690       int mouse_beg_col UNINIT, mouse_end_col UNINIT;
 30691       bool check_mouse_face = false;
 30692       int dummy_x = 0;
 30693 
 30694       /* If mouse highlighting is on, we may need to draw adjacent
 30695          glyphs using mouse-face highlighting.  */
 30696       if (area == TEXT_AREA && row->mouse_face_p
 30697           && hlinfo->mouse_face_beg_row >= 0
 30698           && hlinfo->mouse_face_end_row >= 0)
 30699         {
 30700           ptrdiff_t row_vpos = MATRIX_ROW_VPOS (row, w->current_matrix);
 30701 
 30702           if (row_vpos >= hlinfo->mouse_face_beg_row
 30703               && row_vpos <= hlinfo->mouse_face_end_row)
 30704             {
 30705               check_mouse_face = true;
 30706               mouse_beg_col = (row_vpos == hlinfo->mouse_face_beg_row)
 30707                 ? hlinfo->mouse_face_beg_col : 0;
 30708               mouse_end_col = (row_vpos == hlinfo->mouse_face_end_row)
 30709                 ? hlinfo->mouse_face_end_col
 30710                 : row->used[TEXT_AREA];
 30711             }
 30712         }
 30713 
 30714       /* Compute overhangs for all glyph strings.  */
 30715       if (FRAME_RIF (f)->compute_glyph_string_overhangs)
 30716         for (s = head; s; s = s->next)
 30717           FRAME_RIF (f)->compute_glyph_string_overhangs (s);
 30718 
 30719       /* Prepend glyph strings for glyphs in front of the first glyph
 30720          string that are overwritten because of the first glyph
 30721          string's left overhang.  The background of all strings
 30722          prepended must be drawn because the first glyph string
 30723          draws over it.  */
 30724       i = left_overwritten (head);
 30725       if (i >= 0)
 30726         {
 30727           enum draw_glyphs_face overlap_hl;
 30728 
 30729           /* If this row contains mouse highlighting, attempt to draw
 30730              the overlapped glyphs with the correct highlight.  This
 30731              code fails if the overlap encompasses more than one glyph
 30732              and mouse-highlight spans only some of these glyphs.
 30733              However, making it work perfectly involves a lot more
 30734              code, and I don't know if the pathological case occurs in
 30735              practice, so we'll stick to this for now.  --- cyd  */
 30736           if (check_mouse_face
 30737               && mouse_beg_col < start && mouse_end_col > i)
 30738             overlap_hl = DRAW_MOUSE_FACE;
 30739           else
 30740             overlap_hl = DRAW_NORMAL_TEXT;
 30741 
 30742           if (hl != overlap_hl)
 30743             clip_head = head;
 30744           j = i;
 30745           BUILD_GLYPH_STRINGS (j, start, h, t,
 30746                                overlap_hl, dummy_x, last_x);
 30747           start = i;
 30748           compute_overhangs_and_x (t, head->x, true);
 30749           prepend_glyph_string_lists (&head, &tail, h, t);
 30750           if (clip_head == NULL)
 30751             clip_head = head;
 30752         }
 30753 
 30754       /* Prepend glyph strings for glyphs in front of the first glyph
 30755          string that overwrite that glyph string because of their
 30756          right overhang.  For these strings, only the foreground must
 30757          be drawn, because it draws over the glyph string at `head'.
 30758          The background must not be drawn because this would overwrite
 30759          right overhangs of preceding glyphs for which no glyph
 30760          strings exist.  */
 30761       i = left_overwriting (head);
 30762       if (i >= 0)
 30763         {
 30764           enum draw_glyphs_face overlap_hl;
 30765 
 30766           if (check_mouse_face
 30767               && mouse_beg_col < start && mouse_end_col > i)
 30768             overlap_hl = DRAW_MOUSE_FACE;
 30769           else
 30770             overlap_hl = DRAW_NORMAL_TEXT;
 30771 
 30772           if (hl == overlap_hl || clip_head == NULL)
 30773             clip_head = head;
 30774           BUILD_GLYPH_STRINGS (i, start, h, t,
 30775                                overlap_hl, dummy_x, last_x);
 30776           for (s = h; s; s = s->next)
 30777             s->background_filled_p = true;
 30778           compute_overhangs_and_x (t, head->x, true);
 30779           prepend_glyph_string_lists (&head, &tail, h, t);
 30780         }
 30781 
 30782       /* Append glyphs strings for glyphs following the last glyph
 30783          string tail that are overwritten by tail.  The background of
 30784          these strings has to be drawn because tail's foreground draws
 30785          over it.  */
 30786       i = right_overwritten (tail);
 30787       if (i >= 0)
 30788         {
 30789           enum draw_glyphs_face overlap_hl;
 30790 
 30791           if (check_mouse_face
 30792               && mouse_beg_col < i && mouse_end_col > end)
 30793             overlap_hl = DRAW_MOUSE_FACE;
 30794           else
 30795             overlap_hl = DRAW_NORMAL_TEXT;
 30796 
 30797           if (hl != overlap_hl)
 30798             clip_tail = tail;
 30799           BUILD_GLYPH_STRINGS (end, i, h, t,
 30800                                overlap_hl, x, last_x);
 30801           /* Because BUILD_GLYPH_STRINGS updates the first argument,
 30802              we don't have `end = i;' here.  */
 30803           compute_overhangs_and_x (h, tail->x + tail->width, false);
 30804           append_glyph_string_lists (&head, &tail, h, t);
 30805           if (clip_tail == NULL)
 30806             clip_tail = tail;
 30807         }
 30808 
 30809       /* Append glyph strings for glyphs following the last glyph
 30810          string tail that overwrite tail.  The foreground of such
 30811          glyphs has to be drawn because it writes into the background
 30812          of tail.  The background must not be drawn because it could
 30813          paint over the foreground of following glyphs.  */
 30814       i = right_overwriting (tail);
 30815       if (i >= 0)
 30816         {
 30817           enum draw_glyphs_face overlap_hl;
 30818           if (check_mouse_face
 30819               && mouse_beg_col < i && mouse_end_col > end)
 30820             overlap_hl = DRAW_MOUSE_FACE;
 30821           else
 30822             overlap_hl = DRAW_NORMAL_TEXT;
 30823 
 30824           if (hl == overlap_hl || clip_tail == NULL)
 30825             clip_tail = tail;
 30826           i++;                  /* We must include the Ith glyph.  */
 30827           BUILD_GLYPH_STRINGS (end, i, h, t,
 30828                                overlap_hl, x, last_x);
 30829           for (s = h; s; s = s->next)
 30830             s->background_filled_p = true;
 30831           compute_overhangs_and_x (h, tail->x + tail->width, false);
 30832           append_glyph_string_lists (&head, &tail, h, t);
 30833         }
 30834       tail = glyph_string_containing_background_width (tail);
 30835       if (clip_tail)
 30836         clip_tail = glyph_string_containing_background_width (clip_tail);
 30837       if (clip_head || clip_tail)
 30838         for (s = head; s; s = s->next)
 30839           {
 30840             s->clip_head = clip_head;
 30841             s->clip_tail = clip_tail;
 30842           }
 30843     }
 30844 
 30845   /* Draw all strings.  */
 30846   for (s = head; s; s = s->next)
 30847     FRAME_RIF (f)->draw_glyph_string (s);
 30848 
 30849   /* When focus a sole frame and move horizontally, this clears on_p
 30850      causing a failure to erase prev cursor position. */
 30851   if (area == TEXT_AREA
 30852       && !row->full_width_p
 30853       /* When drawing overlapping rows, only the glyph strings'
 30854          foreground is drawn, which doesn't erase a cursor
 30855          completely. */
 30856       && !overlaps)
 30857     {
 30858       int x0 = clip_head ? clip_head->x : (head ? head->x : x);
 30859       int x1 = (clip_tail ? clip_tail->x + clip_tail->background_width
 30860                 : (tail ? tail->x + tail->background_width : x));
 30861       x0 -= area_left;
 30862       x1 -= area_left;
 30863 
 30864       notice_overwritten_cursor (w, TEXT_AREA, x0, x1,
 30865                                  row->y, MATRIX_ROW_BOTTOM_Y (row));
 30866     }
 30867 
 30868   /* Value is the x-position up to which drawn, relative to AREA of W.
 30869      This doesn't include parts drawn because of overhangs.  */
 30870   if (row->full_width_p)
 30871     x_reached = FRAME_TO_WINDOW_PIXEL_X (w, x_reached);
 30872   else
 30873     x_reached -= area_left;
 30874 
 30875   RELEASE_HDC (hdc, f);
 30876 
 30877   SAFE_FREE ();
 30878   return x_reached;
 30879 }
 30880 
 30881 /* Find the first glyph in the run of underlined glyphs preceding the
 30882    beginning of glyph string S, and return its font (which could be
 30883    NULL).  This is needed because that font determines the underline
 30884    position and thickness for the entire run of the underlined glyphs.
 30885    This function is called from the draw_glyph_string method of GUI
 30886    frame's redisplay interface (RIF) when it needs to draw in an
 30887    underlined face.  */
 30888 struct font *
 30889 font_for_underline_metrics (struct glyph_string *s)
 30890 {
 30891   struct glyph *g0 = s->row->glyphs[s->area], *g;
 30892 
 30893   for (g = s->first_glyph - 1; g >= g0; g--)
 30894     {
 30895       struct face *prev_face = FACE_FROM_ID (s->f, g->face_id);
 30896       if (!(prev_face && prev_face->underline != FACE_NO_UNDERLINE))
 30897         break;
 30898     }
 30899 
 30900   /* If preceding glyphs are not underlined, use the font of S.  */
 30901   if (g == s->first_glyph - 1)
 30902     return s->font;
 30903   else
 30904     {
 30905       /* Otherwise use the font of the last glyph we saw in the above
 30906          loop whose face had the underline_p flag set.  */
 30907       return FACE_FROM_ID (s->f, g[1].face_id)->font;
 30908     }
 30909 }
 30910 
 30911 /* Expand row matrix if too narrow.  Don't expand if area
 30912    is not present.  */
 30913 
 30914 #define IT_EXPAND_MATRIX_WIDTH(it, area)                \
 30915   {                                                     \
 30916     if (!it->f->fonts_changed                           \
 30917         && (it->glyph_row->glyphs[area]                 \
 30918             < it->glyph_row->glyphs[area + 1]))         \
 30919       {                                                 \
 30920         it->w->ncols_scale_factor++;                    \
 30921         it->f->fonts_changed = true;                    \
 30922       }                                                 \
 30923   }
 30924 
 30925 /* Store one glyph for IT->char_to_display in IT->glyph_row.
 30926    Called from gui_produce_glyphs when IT->glyph_row is non-null.  */
 30927 
 30928 static void
 30929 append_glyph (struct it *it)
 30930 {
 30931   struct glyph *glyph;
 30932   enum glyph_row_area area = it->area;
 30933 
 30934   eassert (it->glyph_row);
 30935   eassert (it->char_to_display != '\n' && it->char_to_display != '\t');
 30936 
 30937   glyph = it->glyph_row->glyphs[area] + it->glyph_row->used[area];
 30938   if (glyph < it->glyph_row->glyphs[area + 1])
 30939     {
 30940       /* If the glyph row is reversed, we need to prepend the glyph
 30941          rather than append it.  */
 30942       if (it->glyph_row->reversed_p && area == TEXT_AREA)
 30943         {
 30944           struct glyph *g;
 30945 
 30946           /* Make room for the additional glyph.  */
 30947           for (g = glyph - 1; g >= it->glyph_row->glyphs[area]; g--)
 30948             g[1] = *g;
 30949           glyph = it->glyph_row->glyphs[area];
 30950         }
 30951       glyph->charpos = CHARPOS (it->position);
 30952       glyph->object = it->object;
 30953       if (it->pixel_width > 0)
 30954         {
 30955           eassert (it->pixel_width <= SHRT_MAX);
 30956           glyph->pixel_width = it->pixel_width;
 30957           glyph->padding_p = false;
 30958         }
 30959       else
 30960         {
 30961           /* Assure at least 1-pixel width.  Otherwise, cursor can't
 30962              be displayed correctly.  */
 30963           glyph->pixel_width = 1;
 30964           glyph->padding_p = true;
 30965         }
 30966       glyph->ascent = it->ascent;
 30967       glyph->descent = it->descent;
 30968       glyph->voffset = it->voffset;
 30969       glyph->type = CHAR_GLYPH;
 30970       glyph->avoid_cursor_p = it->avoid_cursor_p;
 30971       glyph->multibyte_p = it->multibyte_p;
 30972       if (it->glyph_row->reversed_p && area == TEXT_AREA)
 30973         {
 30974           /* In R2L rows, the left and the right box edges need to be
 30975              drawn in reverse direction.  */
 30976           glyph->right_box_line_p = it->start_of_box_run_p;
 30977           glyph->left_box_line_p = it->end_of_box_run_p;
 30978         }
 30979       else
 30980         {
 30981           glyph->left_box_line_p = it->start_of_box_run_p;
 30982           glyph->right_box_line_p = it->end_of_box_run_p;
 30983         }
 30984       glyph->overlaps_vertically_p = (it->phys_ascent > it->ascent
 30985                                       || it->phys_descent > it->descent);
 30986       glyph->glyph_not_available_p = it->glyph_not_available_p;
 30987       glyph->face_id = it->face_id;
 30988       glyph->u.ch = it->char_to_display;
 30989       glyph->slice.img = null_glyph_slice;
 30990       glyph->font_type = FONT_TYPE_UNKNOWN;
 30991       if (it->bidi_p)
 30992         {
 30993           glyph->resolved_level = it->bidi_it.resolved_level;
 30994           eassert ((it->bidi_it.type & 7) == it->bidi_it.type);
 30995           glyph->bidi_type = it->bidi_it.type;
 30996         }
 30997       else
 30998         {
 30999           glyph->resolved_level = 0;
 31000           glyph->bidi_type = UNKNOWN_BT;
 31001         }
 31002       ++it->glyph_row->used[area];
 31003     }
 31004   else
 31005     IT_EXPAND_MATRIX_WIDTH (it, area);
 31006 }
 31007 
 31008 /* Store one glyph for the composition IT->cmp_it.id in IT->glyph_row.
 31009    Called from gui_produce_glyphs when IT->glyph_row is non-null.  */
 31010 
 31011 static void
 31012 append_composite_glyph (struct it *it)
 31013 {
 31014   struct glyph *glyph;
 31015   enum glyph_row_area area = it->area;
 31016 
 31017   eassert (it->glyph_row);
 31018 
 31019   glyph = it->glyph_row->glyphs[area] + it->glyph_row->used[area];
 31020   if (glyph < it->glyph_row->glyphs[area + 1])
 31021     {
 31022       /* If the glyph row is reversed, we need to prepend the glyph
 31023          rather than append it.  */
 31024       if (it->glyph_row->reversed_p && it->area == TEXT_AREA)
 31025         {
 31026           struct glyph *g;
 31027 
 31028           /* Make room for the new glyph.  */
 31029           for (g = glyph - 1; g >= it->glyph_row->glyphs[it->area]; g--)
 31030             g[1] = *g;
 31031           glyph = it->glyph_row->glyphs[it->area];
 31032         }
 31033       glyph->charpos = it->cmp_it.charpos;
 31034       glyph->object = it->object;
 31035       eassert (it->pixel_width <= SHRT_MAX);
 31036       glyph->pixel_width = it->pixel_width;
 31037       glyph->ascent = it->ascent;
 31038       glyph->descent = it->descent;
 31039       glyph->voffset = it->voffset;
 31040       glyph->type = COMPOSITE_GLYPH;
 31041       if (it->cmp_it.ch < 0)
 31042         {
 31043           glyph->u.cmp.automatic = false;
 31044           glyph->u.cmp.id = it->cmp_it.id;
 31045           glyph->slice.cmp.from = glyph->slice.cmp.to = 0;
 31046         }
 31047       else
 31048         {
 31049           glyph->u.cmp.automatic = true;
 31050           glyph->u.cmp.id = it->cmp_it.id;
 31051           glyph->slice.cmp.from = it->cmp_it.from;
 31052           glyph->slice.cmp.to = it->cmp_it.to - 1;
 31053         }
 31054       glyph->avoid_cursor_p = it->avoid_cursor_p;
 31055       glyph->multibyte_p = it->multibyte_p;
 31056       if (it->glyph_row->reversed_p && area == TEXT_AREA)
 31057         {
 31058           /* In R2L rows, the left and the right box edges need to be
 31059              drawn in reverse direction.  */
 31060           glyph->right_box_line_p = it->start_of_box_run_p;
 31061           glyph->left_box_line_p = it->end_of_box_run_p;
 31062         }
 31063       else
 31064         {
 31065           glyph->left_box_line_p = it->start_of_box_run_p;
 31066           glyph->right_box_line_p = it->end_of_box_run_p;
 31067         }
 31068       glyph->overlaps_vertically_p = (it->phys_ascent > it->ascent
 31069                                       || it->phys_descent > it->descent);
 31070       glyph->padding_p = false;
 31071       glyph->glyph_not_available_p = it->glyph_not_available_p;
 31072       glyph->face_id = it->face_id;
 31073       glyph->font_type = FONT_TYPE_UNKNOWN;
 31074       if (it->bidi_p)
 31075         {
 31076           glyph->resolved_level = it->bidi_it.resolved_level;
 31077           eassert ((it->bidi_it.type & 7) == it->bidi_it.type);
 31078           glyph->bidi_type = it->bidi_it.type;
 31079         }
 31080       ++it->glyph_row->used[area];
 31081     }
 31082   else
 31083     IT_EXPAND_MATRIX_WIDTH (it, area);
 31084 }
 31085 
 31086 
 31087 /* Change IT->ascent and IT->height according to the setting of
 31088    IT->voffset.  */
 31089 
 31090 static void
 31091 take_vertical_position_into_account (struct it *it)
 31092 {
 31093   if (it->voffset)
 31094     {
 31095       if (it->voffset < 0)
 31096         /* Increase the ascent so that we can display the text higher
 31097            in the line.  */
 31098         it->ascent -= it->voffset;
 31099       else
 31100         /* Increase the descent so that we can display the text lower
 31101            in the line.  */
 31102         it->descent += it->voffset;
 31103     }
 31104 }
 31105 
 31106 
 31107 /* Produce glyphs/get display metrics for the image IT is loaded with.
 31108    See the description of struct display_iterator in dispextern.h for
 31109    an overview of struct display_iterator.  */
 31110 
 31111 static void
 31112 produce_image_glyph (struct it *it)
 31113 {
 31114   struct image *img;
 31115   struct face *face;
 31116   int glyph_ascent, crop;
 31117   struct glyph_slice slice;
 31118 
 31119   eassert (it->what == IT_IMAGE);
 31120 
 31121   face = FACE_FROM_ID (it->f, it->face_id);
 31122   /* Make sure X resources of the face is loaded.  */
 31123   prepare_face_for_display (it->f, face);
 31124 
 31125   if (it->image_id < 0)
 31126     {
 31127       /* Fringe bitmap.  */
 31128       it->ascent = it->phys_ascent = 0;
 31129       it->descent = it->phys_descent = 0;
 31130       it->pixel_width = 0;
 31131       it->nglyphs = 0;
 31132       return;
 31133     }
 31134 
 31135   img = IMAGE_FROM_ID (it->f, it->image_id);
 31136   /* Make sure X resources of the image is loaded.  */
 31137   prepare_image_for_display (it->f, img);
 31138 
 31139   slice.x = slice.y = 0;
 31140   slice.width = img->width;
 31141   slice.height = img->height;
 31142 
 31143   if (FIXNUMP (it->slice.x))
 31144     slice.x = XFIXNUM (it->slice.x);
 31145   else if (FLOATP (it->slice.x))
 31146     slice.x = XFLOAT_DATA (it->slice.x) * img->width;
 31147 
 31148   if (FIXNUMP (it->slice.y))
 31149     slice.y = XFIXNUM (it->slice.y);
 31150   else if (FLOATP (it->slice.y))
 31151     slice.y = XFLOAT_DATA (it->slice.y) * img->height;
 31152 
 31153   if (FIXNUMP (it->slice.width))
 31154     slice.width = XFIXNUM (it->slice.width);
 31155   else if (FLOATP (it->slice.width))
 31156     slice.width = XFLOAT_DATA (it->slice.width) * img->width;
 31157 
 31158   if (FIXNUMP (it->slice.height))
 31159     slice.height = XFIXNUM (it->slice.height);
 31160   else if (FLOATP (it->slice.height))
 31161     slice.height = XFLOAT_DATA (it->slice.height) * img->height;
 31162 
 31163   if (slice.x >= img->width)
 31164     slice.x = img->width;
 31165   if (slice.y >= img->height)
 31166     slice.y = img->height;
 31167   if (slice.x + slice.width >= img->width)
 31168     slice.width = img->width - slice.x;
 31169   if (slice.y + slice.height > img->height)
 31170     slice.height = img->height - slice.y;
 31171 
 31172   if (slice.width == 0 || slice.height == 0)
 31173     return;
 31174 
 31175   it->ascent = it->phys_ascent = glyph_ascent = image_ascent (img, face, &slice);
 31176 
 31177   it->descent = slice.height - glyph_ascent;
 31178   if (slice.y == 0)
 31179     it->descent += img->vmargin;
 31180   if (slice.y + slice.height == img->height)
 31181     it->descent += img->vmargin;
 31182   it->phys_descent = it->descent;
 31183 
 31184   it->pixel_width = slice.width;
 31185   if (slice.x == 0)
 31186     it->pixel_width += img->hmargin;
 31187   if (slice.x + slice.width == img->width)
 31188     it->pixel_width += img->hmargin;
 31189 
 31190   /* It's quite possible for images to have an ascent greater than
 31191      their height, so don't get confused in that case.  */
 31192   if (it->descent < 0)
 31193     it->descent = 0;
 31194 
 31195   it->nglyphs = 1;
 31196 
 31197   if (face->box != FACE_NO_BOX)
 31198     {
 31199       /* If you change the logic here, please change it in
 31200          get_cursor_offset_for_mouse_face as well. */
 31201       if (face->box_horizontal_line_width > 0)
 31202         {
 31203           if (slice.y == 0)
 31204             it->ascent += face->box_horizontal_line_width;
 31205           if (slice.y + slice.height == img->height)
 31206             it->descent += face->box_horizontal_line_width;
 31207         }
 31208 
 31209       if (face->box_vertical_line_width > 0)
 31210         {
 31211           if (it->start_of_box_run_p && slice.x == 0)
 31212             it->pixel_width += face->box_vertical_line_width;
 31213           if (it->end_of_box_run_p && slice.x + slice.width == img->width)
 31214             it->pixel_width += face->box_vertical_line_width;
 31215         }
 31216     }
 31217 
 31218   take_vertical_position_into_account (it);
 31219 
 31220   /* Automatically crop wide image glyphs at right edge so we can
 31221      draw the cursor on same display row.  */
 31222   if ((crop = it->pixel_width - (it->last_visible_x - it->current_x), crop > 0)
 31223       && (it->hpos == 0 || it->pixel_width > it->last_visible_x / 4))
 31224     {
 31225       it->pixel_width -= crop;
 31226       slice.width -= crop;
 31227     }
 31228 
 31229   if (it->glyph_row)
 31230     {
 31231       struct glyph *glyph;
 31232       enum glyph_row_area area = it->area;
 31233 
 31234       glyph = it->glyph_row->glyphs[area] + it->glyph_row->used[area];
 31235       if (it->glyph_row->reversed_p)
 31236         {
 31237           struct glyph *g;
 31238 
 31239           /* Make room for the new glyph.  */
 31240           for (g = glyph - 1; g >= it->glyph_row->glyphs[it->area]; g--)
 31241             g[1] = *g;
 31242           glyph = it->glyph_row->glyphs[it->area];
 31243         }
 31244       if (glyph < it->glyph_row->glyphs[area + 1])
 31245         {
 31246           glyph->charpos = CHARPOS (it->position);
 31247           glyph->object = it->object;
 31248           glyph->pixel_width = clip_to_bounds (-1, it->pixel_width, SHRT_MAX);
 31249           glyph->ascent = glyph_ascent;
 31250           glyph->descent = it->descent;
 31251           glyph->voffset = it->voffset;
 31252           glyph->type = IMAGE_GLYPH;
 31253           glyph->avoid_cursor_p = it->avoid_cursor_p;
 31254           glyph->multibyte_p = it->multibyte_p;
 31255           if (it->glyph_row->reversed_p && area == TEXT_AREA)
 31256             {
 31257               /* In R2L rows, the left and the right box edges need to be
 31258                  drawn in reverse direction.  */
 31259               glyph->right_box_line_p = it->start_of_box_run_p;
 31260               glyph->left_box_line_p = it->end_of_box_run_p;
 31261             }
 31262           else
 31263             {
 31264               glyph->left_box_line_p = it->start_of_box_run_p;
 31265               glyph->right_box_line_p = it->end_of_box_run_p;
 31266             }
 31267           glyph->overlaps_vertically_p = false;
 31268           glyph->padding_p = false;
 31269           glyph->glyph_not_available_p = false;
 31270           glyph->face_id = it->face_id;
 31271           glyph->u.img_id = img->id;
 31272           glyph->slice.img = slice;
 31273           glyph->font_type = FONT_TYPE_UNKNOWN;
 31274           if (it->bidi_p)
 31275             {
 31276               glyph->resolved_level = it->bidi_it.resolved_level;
 31277               eassert ((it->bidi_it.type & 7) == it->bidi_it.type);
 31278               glyph->bidi_type = it->bidi_it.type;
 31279             }
 31280           ++it->glyph_row->used[area];
 31281         }
 31282       else
 31283         IT_EXPAND_MATRIX_WIDTH (it, area);
 31284     }
 31285 }
 31286 
 31287 static void
 31288 produce_xwidget_glyph (struct it *it)
 31289 {
 31290 #ifdef HAVE_XWIDGETS
 31291   struct xwidget *xw;
 31292   int glyph_ascent, crop;
 31293   eassert (it->what == IT_XWIDGET);
 31294 
 31295   struct face *face = FACE_FROM_ID (it->f, it->face_id);
 31296   /* Make sure X resources of the face is loaded.  */
 31297   prepare_face_for_display (it->f, face);
 31298 
 31299   xw = it->xwidget;
 31300   it->ascent = it->phys_ascent = glyph_ascent = xw->height/2;
 31301   it->descent = xw->height/2;
 31302   it->phys_descent = it->descent;
 31303   it->pixel_width = xw->width;
 31304   /* It's quite possible for images to have an ascent greater than
 31305      their height, so don't get confused in that case.  */
 31306   if (it->descent < 0)
 31307     it->descent = 0;
 31308 
 31309   it->nglyphs = 1;
 31310 
 31311   if (face->box != FACE_NO_BOX)
 31312     {
 31313       if (face->box_horizontal_line_width > 0)
 31314         {
 31315           it->ascent += face->box_horizontal_line_width;
 31316           it->descent += face->box_horizontal_line_width;
 31317         }
 31318 
 31319       if (face->box_vertical_line_width > 0)
 31320         {
 31321           if (it->start_of_box_run_p)
 31322             it->pixel_width += face->box_vertical_line_width;
 31323           it->pixel_width += face->box_vertical_line_width;
 31324         }
 31325     }
 31326 
 31327   take_vertical_position_into_account (it);
 31328 
 31329   /* Automatically crop wide image glyphs at right edge so we can
 31330      draw the cursor on same display row.  */
 31331   crop = it->pixel_width - (it->last_visible_x - it->current_x);
 31332   if (crop > 0 && (it->hpos == 0 || it->pixel_width > it->last_visible_x / 4))
 31333     it->pixel_width -= crop;
 31334 
 31335   if (it->glyph_row)
 31336     {
 31337       enum glyph_row_area area = it->area;
 31338       struct glyph *glyph
 31339         = it->glyph_row->glyphs[area] + it->glyph_row->used[area];
 31340 
 31341       if (it->glyph_row->reversed_p)
 31342         {
 31343           struct glyph *g;
 31344 
 31345           /* Make room for the new glyph.  */
 31346           for (g = glyph - 1; g >= it->glyph_row->glyphs[it->area]; g--)
 31347             g[1] = *g;
 31348           glyph = it->glyph_row->glyphs[it->area];
 31349         }
 31350       if (glyph < it->glyph_row->glyphs[area + 1])
 31351         {
 31352           glyph->charpos = CHARPOS (it->position);
 31353           glyph->object = it->object;
 31354           glyph->pixel_width = clip_to_bounds (-1, it->pixel_width, SHRT_MAX);
 31355           glyph->ascent = glyph_ascent;
 31356           glyph->descent = it->descent;
 31357           glyph->voffset = it->voffset;
 31358           glyph->type = XWIDGET_GLYPH;
 31359           glyph->avoid_cursor_p = it->avoid_cursor_p;
 31360           glyph->multibyte_p = it->multibyte_p;
 31361           if (it->glyph_row->reversed_p && area == TEXT_AREA)
 31362             {
 31363               /* In R2L rows, the left and the right box edges need to be
 31364                  drawn in reverse direction.  */
 31365               glyph->right_box_line_p = it->start_of_box_run_p;
 31366               glyph->left_box_line_p = it->end_of_box_run_p;
 31367             }
 31368           else
 31369             {
 31370               glyph->left_box_line_p = it->start_of_box_run_p;
 31371               glyph->right_box_line_p = it->end_of_box_run_p;
 31372             }
 31373           glyph->overlaps_vertically_p = 0;
 31374           glyph->padding_p = 0;
 31375           glyph->glyph_not_available_p = 0;
 31376           glyph->face_id = it->face_id;
 31377           glyph->u.xwidget = it->xwidget->xwidget_id;
 31378           glyph->font_type = FONT_TYPE_UNKNOWN;
 31379           if (it->bidi_p)
 31380             {
 31381               glyph->resolved_level = it->bidi_it.resolved_level;
 31382               eassert ((it->bidi_it.type & 7) == it->bidi_it.type);
 31383               glyph->bidi_type = it->bidi_it.type;
 31384             }
 31385           ++it->glyph_row->used[area];
 31386         }
 31387       else
 31388         IT_EXPAND_MATRIX_WIDTH (it, area);
 31389     }
 31390 #endif
 31391 }
 31392 
 31393 /* Append a stretch glyph to IT->glyph_row.  OBJECT is the source
 31394    of the glyph, WIDTH and HEIGHT are the width and height of the
 31395    stretch.  ASCENT is the ascent of the glyph (0 <= ASCENT <= HEIGHT).  */
 31396 
 31397 static void
 31398 append_stretch_glyph (struct it *it, Lisp_Object object,
 31399                       int width, int height, int ascent)
 31400 {
 31401   struct glyph *glyph;
 31402   enum glyph_row_area area = it->area;
 31403 
 31404   eassert (ascent >= 0 && ascent <= height);
 31405 
 31406   glyph = it->glyph_row->glyphs[area] + it->glyph_row->used[area];
 31407   if (glyph < it->glyph_row->glyphs[area + 1])
 31408     {
 31409       /* If the glyph row is reversed, we need to prepend the glyph
 31410          rather than append it.  */
 31411       if (it->glyph_row->reversed_p && area == TEXT_AREA)
 31412         {
 31413           struct glyph *g;
 31414 
 31415           /* Make room for the additional glyph.  */
 31416           for (g = glyph - 1; g >= it->glyph_row->glyphs[area]; g--)
 31417             g[1] = *g;
 31418           glyph = it->glyph_row->glyphs[area];
 31419 
 31420           /* Decrease the width of the first glyph of the row that
 31421              begins before first_visible_x (e.g., due to hscroll).
 31422              This is so the overall width of the row becomes smaller
 31423              by the scroll amount, and the stretch glyph appended by
 31424              extend_face_to_end_of_line will be wider, to shift the
 31425              row glyphs to the right.  (In L2R rows, the corresponding
 31426              left-shift effect is accomplished by setting row->x to a
 31427              negative value, which won't work with R2L rows.)
 31428 
 31429              This must leave us with a positive value of WIDTH, since
 31430              otherwise the call to move_it_in_display_line_to at the
 31431              beginning of display_line would have got past the entire
 31432              first glyph, and then it->current_x would have been
 31433              greater or equal to it->first_visible_x.  */
 31434           if (it->current_x < it->first_visible_x)
 31435             width -= it->first_visible_x - it->current_x;
 31436           eassert (width > 0);
 31437         }
 31438       glyph->charpos = CHARPOS (it->position);
 31439       glyph->object = object;
 31440       /* FIXME: It would be better to use TYPE_MAX here, but
 31441          __typeof__ is not portable enough...  */
 31442       glyph->pixel_width = clip_to_bounds (-1, width, SHRT_MAX);
 31443       glyph->ascent = ascent;
 31444       glyph->descent = height - ascent;
 31445       glyph->voffset = it->voffset;
 31446       glyph->type = STRETCH_GLYPH;
 31447       glyph->avoid_cursor_p = it->avoid_cursor_p;
 31448       glyph->multibyte_p = it->multibyte_p;
 31449       if (it->glyph_row->reversed_p && area == TEXT_AREA)
 31450         {
 31451           /* In R2L rows, the left and the right box edges need to be
 31452              drawn in reverse direction.  */
 31453           glyph->right_box_line_p = it->start_of_box_run_p;
 31454           glyph->left_box_line_p = it->end_of_box_run_p;
 31455         }
 31456       else
 31457         {
 31458           glyph->left_box_line_p = it->start_of_box_run_p;
 31459           glyph->right_box_line_p = it->end_of_box_run_p;
 31460         }
 31461       glyph->overlaps_vertically_p = false;
 31462       glyph->padding_p = false;
 31463       glyph->glyph_not_available_p = false;
 31464       glyph->face_id = it->face_id;
 31465       glyph->u.stretch.ascent = ascent;
 31466       glyph->u.stretch.height = height;
 31467       glyph->slice.img = null_glyph_slice;
 31468       glyph->font_type = FONT_TYPE_UNKNOWN;
 31469       if (it->bidi_p)
 31470         {
 31471           glyph->resolved_level = it->bidi_it.resolved_level;
 31472           eassert ((it->bidi_it.type & 7) == it->bidi_it.type);
 31473           glyph->bidi_type = it->bidi_it.type;
 31474         }
 31475       else
 31476         {
 31477           glyph->resolved_level = 0;
 31478           glyph->bidi_type = UNKNOWN_BT;
 31479         }
 31480       ++it->glyph_row->used[area];
 31481     }
 31482   else
 31483     IT_EXPAND_MATRIX_WIDTH (it, area);
 31484 }
 31485 
 31486 #endif  /* HAVE_WINDOW_SYSTEM */
 31487 
 31488 /* Produce a stretch glyph for iterator IT.  IT->object is the value
 31489    of the display property.  The value must be a list of the form
 31490    `(space KEYWORD VALUE ...)' with the following KEYWORD/VALUE pairs
 31491    being recognized:
 31492 
 31493    1. `:width WIDTH' specifies that the space should be WIDTH *
 31494    canonical char width wide.  WIDTH may be an integer or floating
 31495    point number.
 31496 
 31497    2. `:relative-width FACTOR' specifies that the width of the stretch
 31498    should be computed from the width of the first character having the
 31499    `display' property, and should be FACTOR times that width.
 31500 
 31501    3. `:align-to HPOS' specifies that the space should be wide enough
 31502    to reach HPOS, a value in canonical character units.
 31503 
 31504    Exactly one of the above pairs must be present.
 31505 
 31506    4. `:height HEIGHT' specifies that the height of the stretch produced
 31507    should be HEIGHT, measured in canonical character units.
 31508 
 31509    5. `:relative-height FACTOR' specifies that the height of the
 31510    stretch should be FACTOR times the height of the characters having
 31511    the display property.
 31512 
 31513    Either none or exactly one of 4 or 5 must be present.
 31514 
 31515    6. `:ascent ASCENT'  specifies that ASCENT percent of the height
 31516    of the stretch should be used for the ascent of the stretch.
 31517    ASCENT must be in the range 0 <= ASCENT <= 100.  */
 31518 
 31519 void
 31520 produce_stretch_glyph (struct it *it)
 31521 {
 31522   /* (space :width WIDTH :height HEIGHT ...)  */
 31523   Lisp_Object prop, plist;
 31524   int width = 0, height = 0, align_to = -1;
 31525   bool zero_width_ok_p = false;
 31526   double tem;
 31527   struct font *font = NULL;
 31528 
 31529 #ifdef HAVE_WINDOW_SYSTEM
 31530   int ascent = 0;
 31531   bool zero_height_ok_p = false;
 31532   struct face *face = NULL;     /* shut up GCC's -Wmaybe-uninitialized */
 31533 
 31534   if (FRAME_WINDOW_P (it->f))
 31535     {
 31536       face = FACE_FROM_ID (it->f, it->face_id);
 31537       font = face->font ? face->font : FRAME_FONT (it->f);
 31538       prepare_face_for_display (it->f, face);
 31539     }
 31540 #endif
 31541 
 31542   /* List should start with `space'.  */
 31543   eassert (CONSP (it->object) && EQ (XCAR (it->object), Qspace));
 31544   plist = XCDR (it->object);
 31545 
 31546   /* Compute the width of the stretch.  */
 31547   if ((prop = plist_get (plist, QCwidth), !NILP (prop))
 31548       && calc_pixel_width_or_height (&tem, it, prop, font, true, NULL))
 31549     {
 31550       /* Absolute width `:width WIDTH' specified and valid.  */
 31551       zero_width_ok_p = true;
 31552       width = (int)tem;
 31553     }
 31554   else if (prop = plist_get (plist, QCrelative_width), NUMVAL (prop) > 0)
 31555     {
 31556       /* Relative width `:relative-width FACTOR' specified and valid.
 31557          Compute the width of the characters having this `display'
 31558          property.  */
 31559       struct it it2;
 31560       Lisp_Object object =
 31561         it->sp > 0 ? it->stack[it->sp - 1].string : it->string;
 31562       unsigned char *p = (STRINGP (object)
 31563                           ? SDATA (object) + IT_STRING_BYTEPOS (*it)
 31564                           : BYTE_POS_ADDR (IT_BYTEPOS (*it)));
 31565       bool multibyte_p =
 31566         STRINGP (object) ? STRING_MULTIBYTE (object) : it->multibyte_p;
 31567 
 31568       it2 = *it;
 31569       if (multibyte_p)
 31570         {
 31571           it2.c = it2.char_to_display = string_char_and_length (p, &it2.len);
 31572 #ifdef HAVE_WINDOW_SYSTEM
 31573           if (FRAME_WINDOW_P (it->f) && ! ASCII_CHAR_P (it2.c))
 31574             it2.face_id = FACE_FOR_CHAR (it->f, face, it2.c,
 31575                                          IT_CHARPOS (*it),
 31576                                          STRINGP (object)? object : Qnil);
 31577 #endif
 31578         }
 31579       else
 31580         {
 31581           it2.c = it2.char_to_display = *p, it2.len = 1;
 31582           if (! ASCII_CHAR_P (it2.c))
 31583             it2.char_to_display = BYTE8_TO_CHAR (it2.c);
 31584         }
 31585 
 31586       it2.glyph_row = NULL;
 31587       it2.what = IT_CHARACTER;
 31588       PRODUCE_GLYPHS (&it2);
 31589       width = NUMVAL (prop) * it2.pixel_width;
 31590     }
 31591   else if ((prop = plist_get (plist, QCalign_to), !NILP (prop))
 31592            && calc_pixel_width_or_height (&tem, it, prop, font, true,
 31593                                           &align_to))
 31594     {
 31595       int x = it->current_x + it->continuation_lines_width;
 31596       int x0 = x;
 31597       /* Adjust for line numbers, if needed.   */
 31598       if (!NILP (Vdisplay_line_numbers) && it->line_number_produced_p)
 31599         {
 31600           x -= it->lnum_pixel_width;
 31601           /* Restore the original width, if required.  */
 31602           if (x + it->stretch_adjust >= it->first_visible_x)
 31603             x += it->stretch_adjust;
 31604         }
 31605 
 31606       if (it->glyph_row == NULL || !it->glyph_row->mode_line_p)
 31607         align_to = (align_to < 0
 31608                     ? 0
 31609                     : align_to - window_box_left_offset (it->w, TEXT_AREA));
 31610       else if (align_to < 0)
 31611         align_to = window_box_left_offset (it->w, TEXT_AREA);
 31612       width = max (0, (int)tem + align_to - x);
 31613 
 31614       int next_x = x + width;
 31615       if (!NILP (Vdisplay_line_numbers) && it->line_number_produced_p)
 31616         {
 31617           /* If the line is hscrolled, and the stretch starts before
 31618              the first visible pixel, simulate negative row->x.  */
 31619           if (x < it->first_visible_x)
 31620             {
 31621               next_x -= it->first_visible_x - x;
 31622               it->stretch_adjust = it->first_visible_x - x;
 31623             }
 31624           else
 31625             next_x -= it->stretch_adjust;
 31626         }
 31627       width = next_x - x0;
 31628       zero_width_ok_p = true;
 31629     }
 31630   else
 31631     /* Nothing specified -> width defaults to canonical char width.  */
 31632     width = FRAME_COLUMN_WIDTH (it->f);
 31633 
 31634   if (width <= 0 && (width < 0 || !zero_width_ok_p))
 31635     width = 1;
 31636 
 31637 #ifdef HAVE_WINDOW_SYSTEM
 31638   /* Compute height.  */
 31639   if (FRAME_WINDOW_P (it->f))
 31640     {
 31641       int default_height = normal_char_height (font, ' ');
 31642 
 31643       if ((prop = plist_get (plist, QCheight), !NILP (prop))
 31644           && calc_pixel_width_or_height (&tem, it, prop, font, false, NULL))
 31645         {
 31646           height = (int)tem;
 31647           zero_height_ok_p = true;
 31648         }
 31649       else if (prop = plist_get (plist, QCrelative_height),
 31650                NUMVAL (prop) > 0)
 31651         height = default_height * NUMVAL (prop);
 31652       else
 31653         height = default_height;
 31654 
 31655       if (height <= 0 && (height < 0 || !zero_height_ok_p))
 31656         height = 1;
 31657 
 31658       /* Compute percentage of height used for ascent.  If
 31659          `:ascent ASCENT' is present and valid, use that.  Otherwise,
 31660          derive the ascent from the font in use.  */
 31661       if (prop = plist_get (plist, QCascent),
 31662           NUMVAL (prop) > 0 && NUMVAL (prop) <= 100)
 31663         ascent = height * NUMVAL (prop) / 100.0;
 31664       else if (!NILP (prop)
 31665                && calc_pixel_width_or_height (&tem, it, prop, font, false, 0))
 31666         ascent = min (max (0, (int)tem), height);
 31667       else
 31668         ascent = (height * FONT_BASE (font)) / FONT_HEIGHT (font);
 31669     }
 31670   else
 31671 #endif  /* HAVE_WINDOW_SYSTEM */
 31672     height = 1;
 31673 
 31674   if (width > 0
 31675       && it->area == TEXT_AREA && it->line_wrap != TRUNCATE
 31676       && it->current_x + width > it->last_visible_x)
 31677     {
 31678       width = it->last_visible_x - it->current_x;
 31679 #ifdef HAVE_WINDOW_SYSTEM
 31680       /* Subtract one more pixel from the stretch width, but only on
 31681          GUI frames, since on a TTY each glyph is one "pixel" wide.  */
 31682       width -= FRAME_WINDOW_P (it->f);
 31683 #endif
 31684     }
 31685 
 31686   if (width > 0 && height > 0 && it->glyph_row)
 31687     {
 31688       Lisp_Object o_object = it->object;
 31689       Lisp_Object object =
 31690         it->sp > 0 ? it->stack[it->sp - 1].string : it->string;
 31691       int n = width;
 31692 
 31693       if (!STRINGP (object))
 31694         object = it->w->contents;
 31695 #ifdef HAVE_WINDOW_SYSTEM
 31696       if (FRAME_WINDOW_P (it->f))
 31697         append_stretch_glyph (it, object, width, height, ascent);
 31698       else
 31699 #endif
 31700         {
 31701           it->object = object;
 31702           it->char_to_display = ' ';
 31703           it->pixel_width = it->len = 1;
 31704           while (n--)
 31705             tty_append_glyph (it);
 31706           it->object = o_object;
 31707         }
 31708     }
 31709 
 31710   it->pixel_width = width;
 31711 #ifdef HAVE_WINDOW_SYSTEM
 31712   if (FRAME_WINDOW_P (it->f))
 31713     {
 31714       it->ascent = it->phys_ascent = ascent;
 31715       it->descent = it->phys_descent = height - it->ascent;
 31716       it->nglyphs = width > 0 && height > 0;
 31717       take_vertical_position_into_account (it);
 31718     }
 31719   else
 31720 #endif
 31721     it->nglyphs = width;
 31722 }
 31723 
 31724 /* Get information about special display element WHAT in an
 31725    environment described by IT.  WHAT is one of IT_TRUNCATION or
 31726    IT_CONTINUATION.  Maybe produce glyphs for WHAT if IT has a
 31727    non-null glyph_row member.  This function ensures that fields like
 31728    face_id, c, len of IT are left untouched.  */
 31729 
 31730 static void
 31731 produce_special_glyphs (struct it *it, enum display_element_type what)
 31732 {
 31733   struct it temp_it;
 31734   Lisp_Object gc;
 31735   GLYPH glyph;
 31736 
 31737   temp_it = *it;
 31738   temp_it.object = Qnil;
 31739   memset (&temp_it.current, 0, sizeof temp_it.current);
 31740 
 31741   if (what == IT_CONTINUATION)
 31742     {
 31743       /* Continuation glyph.  For R2L lines, we mirror it by hand.  */
 31744       if (it->bidi_it.paragraph_dir == R2L)
 31745         SET_GLYPH_FROM_CHAR (glyph, '/');
 31746       else
 31747         SET_GLYPH_FROM_CHAR (glyph, '\\');
 31748       if (it->dp
 31749           && (gc = DISP_CONTINUE_GLYPH (it->dp), GLYPH_CODE_P (gc)))
 31750         {
 31751           /* FIXME: Should we mirror GC for R2L lines?  */
 31752           SET_GLYPH_FROM_GLYPH_CODE (glyph, gc);
 31753           spec_glyph_lookup_face (XWINDOW (it->window), &glyph);
 31754         }
 31755     }
 31756   else if (what == IT_TRUNCATION)
 31757     {
 31758       /* Truncation glyph.  */
 31759       SET_GLYPH_FROM_CHAR (glyph, '$');
 31760       if (it->dp
 31761           && (gc = DISP_TRUNC_GLYPH (it->dp), GLYPH_CODE_P (gc)))
 31762         {
 31763           /* FIXME: Should we mirror GC for R2L lines?  */
 31764           SET_GLYPH_FROM_GLYPH_CODE (glyph, gc);
 31765           spec_glyph_lookup_face (XWINDOW (it->window), &glyph);
 31766         }
 31767     }
 31768   else
 31769     emacs_abort ();
 31770 
 31771 #ifdef HAVE_WINDOW_SYSTEM
 31772   /* On a GUI frame, when the right fringe (left fringe for R2L rows)
 31773      is turned off, we precede the truncation/continuation glyphs by a
 31774      stretch glyph whose width is computed such that these special
 31775      glyphs are aligned at the window margin, even when very different
 31776      fonts are used in different glyph rows.  */
 31777   if (FRAME_WINDOW_P (temp_it.f)
 31778       /* init_iterator calls this with it->glyph_row == NULL, and it
 31779          wants only the pixel width of the truncation/continuation
 31780          glyphs.  */
 31781       && temp_it.glyph_row
 31782       /* insert_left_trunc_glyphs calls us at the beginning of the
 31783          row, and it has its own calculation of the stretch glyph
 31784          width.  */
 31785       && temp_it.glyph_row->used[TEXT_AREA] > 0
 31786       && (temp_it.glyph_row->reversed_p
 31787           ? WINDOW_LEFT_FRINGE_WIDTH (temp_it.w)
 31788           : WINDOW_RIGHT_FRINGE_WIDTH (temp_it.w)) == 0)
 31789     {
 31790       int stretch_width = temp_it.last_visible_x - temp_it.current_x;
 31791 
 31792       if (stretch_width > 0)
 31793         {
 31794           struct face *face = FACE_FROM_ID (temp_it.f, temp_it.face_id);
 31795           struct font *font =
 31796             face->font ? face->font : FRAME_FONT (temp_it.f);
 31797           int stretch_ascent =
 31798             (((temp_it.ascent + temp_it.descent)
 31799               * FONT_BASE (font)) / FONT_HEIGHT (font));
 31800 
 31801           append_stretch_glyph (&temp_it, Qnil, stretch_width,
 31802                                 temp_it.ascent + temp_it.descent,
 31803                                 stretch_ascent);
 31804         }
 31805     }
 31806 #endif
 31807 
 31808   temp_it.dp = NULL;
 31809   temp_it.what = IT_CHARACTER;
 31810   temp_it.c = temp_it.char_to_display = GLYPH_CHAR (glyph);
 31811   temp_it.face_id = GLYPH_FACE (glyph);
 31812   temp_it.len = CHAR_BYTES (temp_it.c);
 31813 
 31814   PRODUCE_GLYPHS (&temp_it);
 31815   it->pixel_width = temp_it.pixel_width;
 31816   it->nglyphs = temp_it.nglyphs;
 31817 }
 31818 
 31819 /* Produce padding glyphs for mode/header/tab-line whose text needs to
 31820    be truncated.  This is used when the last visible character leaves
 31821    one or more columns till the window edge, but the next character is
 31822    wider than that number of columns, and therefore cannot fit on the
 31823    line.  We then replace these columns with the appropriate padding
 31824    character: '-' for the mode line and SPC for the other two.  That's
 31825    because these lines should not show the usual truncation glyphs
 31826    there.  This function is only used on TTY frames.  */
 31827 static void
 31828 pad_mode_line (struct it *it, bool mode_line_p)
 31829 {
 31830   struct it temp_it;
 31831   GLYPH glyph;
 31832 
 31833   eassert (!FRAME_WINDOW_P (it->f));
 31834   temp_it = *it;
 31835   temp_it.object = Qnil;
 31836   memset (&temp_it.current, 0, sizeof temp_it.current);
 31837 
 31838   SET_GLYPH (glyph, mode_line_p ? '-' : ' ', it->base_face_id);
 31839 
 31840   temp_it.dp = NULL;
 31841   temp_it.what = IT_CHARACTER;
 31842   temp_it.c = temp_it.char_to_display = GLYPH_CHAR (glyph);
 31843   temp_it.face_id = GLYPH_FACE (glyph);
 31844   temp_it.len = CHAR_BYTES (temp_it.c);
 31845 
 31846   PRODUCE_GLYPHS (&temp_it);
 31847   it->pixel_width = temp_it.pixel_width;
 31848   it->nglyphs = temp_it.nglyphs;
 31849 }
 31850 
 31851 #ifdef HAVE_WINDOW_SYSTEM
 31852 
 31853 /* Calculate line-height and line-spacing properties.
 31854    An integer value specifies explicit pixel value.
 31855    A float value specifies relative value to current face height.
 31856    A cons (float . face-name) specifies relative value to
 31857    height of specified face font.
 31858 
 31859    Returns height in pixels, or nil.  */
 31860 
 31861 static Lisp_Object
 31862 calc_line_height_property (struct it *it, Lisp_Object val, struct font *font,
 31863                            int boff, bool override)
 31864 {
 31865   Lisp_Object face_name = Qnil;
 31866   int ascent, descent, height;
 31867 
 31868   if (NILP (val) || INTEGERP (val) || (override && EQ (val, Qt)))
 31869     return val;
 31870 
 31871   if (CONSP (val))
 31872     {
 31873       face_name = XCAR (val);
 31874       val = XCDR (val);
 31875       if (!NUMBERP (val))
 31876         val = make_fixnum (1);
 31877       if (NILP (face_name))
 31878         {
 31879           height = it->ascent + it->descent;
 31880           goto scale;
 31881         }
 31882     }
 31883 
 31884   if (NILP (face_name))
 31885     {
 31886       font = FRAME_FONT (it->f);
 31887       boff = FRAME_BASELINE_OFFSET (it->f);
 31888     }
 31889   else if (EQ (face_name, Qt))
 31890     {
 31891       override = false;
 31892     }
 31893   else
 31894     {
 31895       int face_id;
 31896       struct face *face;
 31897 
 31898       face_id = lookup_named_face (it->w, it->f, face_name, false);
 31899       face = FACE_FROM_ID_OR_NULL (it->f, face_id);
 31900       if (face == NULL || ((font = face->font) == NULL))
 31901         return make_fixnum (-1);
 31902       boff = font->baseline_offset;
 31903       if (font->vertical_centering)
 31904         boff = VCENTER_BASELINE_OFFSET (font, it->f) - boff;
 31905     }
 31906 
 31907   normal_char_ascent_descent (font, -1, &ascent, &descent);
 31908 
 31909   if (override)
 31910     {
 31911       it->override_ascent = ascent;
 31912       it->override_descent = descent;
 31913       it->override_boff = boff;
 31914     }
 31915 
 31916   height = ascent + descent;
 31917 
 31918  scale:
 31919   /* FIXME: Check for overflow in multiplication or conversion.  */
 31920   if (FLOATP (val))
 31921     height = (int)(XFLOAT_DATA (val) * height);
 31922   else if (INTEGERP (val))
 31923     {
 31924       intmax_t v;
 31925       if (integer_to_intmax (val, &v))
 31926         height *= v;
 31927     }
 31928 
 31929   return make_fixnum (height);
 31930 }
 31931 
 31932 
 31933 /* Append a glyph for a glyphless character to IT->glyph_row.  FACE_ID
 31934    is a face ID to be used for the glyph.  FOR_NO_FONT is true if
 31935    and only if this is for a character for which no font was found.
 31936 
 31937    If the display method (it->glyphless_method) is
 31938    GLYPHLESS_DISPLAY_ACRONYM or GLYPHLESS_DISPLAY_HEX_CODE, LEN is a
 31939    length of the acronym or the hexadecimal string, UPPER_XOFF and
 31940    UPPER_YOFF are pixel offsets for the upper part of the string,
 31941    LOWER_XOFF and LOWER_YOFF are for the lower part.
 31942 
 31943    For the other display methods, LEN through LOWER_YOFF are zero.  */
 31944 
 31945 static void
 31946 append_glyphless_glyph (struct it *it, int face_id, bool for_no_font, int len,
 31947                         short upper_xoff, short upper_yoff,
 31948                         short lower_xoff, short lower_yoff)
 31949 {
 31950   struct glyph *glyph;
 31951   enum glyph_row_area area = it->area;
 31952 
 31953   glyph = it->glyph_row->glyphs[area] + it->glyph_row->used[area];
 31954   if (glyph < it->glyph_row->glyphs[area + 1])
 31955     {
 31956       /* If the glyph row is reversed, we need to prepend the glyph
 31957          rather than append it.  */
 31958       if (it->glyph_row->reversed_p && area == TEXT_AREA)
 31959         {
 31960           struct glyph *g;
 31961 
 31962           /* Make room for the additional glyph.  */
 31963           for (g = glyph - 1; g >= it->glyph_row->glyphs[area]; g--)
 31964             g[1] = *g;
 31965           glyph = it->glyph_row->glyphs[area];
 31966         }
 31967       glyph->charpos = CHARPOS (it->position);
 31968       glyph->object = it->object;
 31969       eassert (it->pixel_width <= SHRT_MAX);
 31970       glyph->pixel_width = it->pixel_width;
 31971       glyph->ascent = it->ascent;
 31972       glyph->descent = it->descent;
 31973       glyph->voffset = it->voffset;
 31974       glyph->type = GLYPHLESS_GLYPH;
 31975       glyph->u.glyphless.method = it->glyphless_method;
 31976       glyph->u.glyphless.for_no_font = for_no_font;
 31977       glyph->u.glyphless.len = len;
 31978       glyph->u.glyphless.ch = it->c;
 31979       glyph->slice.glyphless.upper_xoff = upper_xoff;
 31980       glyph->slice.glyphless.upper_yoff = upper_yoff;
 31981       glyph->slice.glyphless.lower_xoff = lower_xoff;
 31982       glyph->slice.glyphless.lower_yoff = lower_yoff;
 31983       glyph->avoid_cursor_p = it->avoid_cursor_p;
 31984       glyph->multibyte_p = it->multibyte_p;
 31985       if (it->glyph_row->reversed_p && area == TEXT_AREA)
 31986         {
 31987           /* In R2L rows, the left and the right box edges need to be
 31988              drawn in reverse direction.  */
 31989           glyph->right_box_line_p = it->start_of_box_run_p;
 31990           glyph->left_box_line_p = it->end_of_box_run_p;
 31991         }
 31992       else
 31993         {
 31994           glyph->left_box_line_p = it->start_of_box_run_p;
 31995           glyph->right_box_line_p = it->end_of_box_run_p;
 31996         }
 31997       glyph->overlaps_vertically_p = (it->phys_ascent > it->ascent
 31998                                       || it->phys_descent > it->descent);
 31999       glyph->padding_p = false;
 32000       glyph->glyph_not_available_p = false;
 32001       glyph->face_id = face_id;
 32002       glyph->font_type = FONT_TYPE_UNKNOWN;
 32003       if (it->bidi_p)
 32004         {
 32005           glyph->resolved_level = it->bidi_it.resolved_level;
 32006           eassert ((it->bidi_it.type & 7) == it->bidi_it.type);
 32007           glyph->bidi_type = it->bidi_it.type;
 32008         }
 32009       ++it->glyph_row->used[area];
 32010     }
 32011   else
 32012     IT_EXPAND_MATRIX_WIDTH (it, area);
 32013 }
 32014 
 32015 
 32016 /* Produce a glyph for a glyphless character for iterator IT.
 32017    IT->glyphless_method specifies which method to use for displaying
 32018    the character.  See the description of enum
 32019    glyphless_display_method in dispextern.h for the detail.
 32020 
 32021    FOR_NO_FONT is true if and only if this is for a character for
 32022    which no font was found.  ACRONYM, if non-nil, is an acronym string
 32023    for the character.  */
 32024 
 32025 static void
 32026 produce_glyphless_glyph (struct it *it, bool for_no_font, Lisp_Object acronym)
 32027 {
 32028   int face_id;
 32029   struct face *face;
 32030   struct font *font;
 32031   int base_width, base_height, width, height;
 32032   short upper_xoff, upper_yoff, lower_xoff, lower_yoff;
 32033   int len;
 32034 
 32035   /* Get the metrics of the base font.  We always refer to the current
 32036      ASCII face.  */
 32037   face = FACE_FROM_ID (it->f, it->face_id)->ascii_face;
 32038   font = face->font ? face->font : FRAME_FONT (it->f);
 32039   normal_char_ascent_descent (font, -1, &it->ascent, &it->descent);
 32040   it->ascent += font->baseline_offset;
 32041   it->descent -= font->baseline_offset;
 32042   base_height = it->ascent + it->descent;
 32043   base_width = font->average_width;
 32044 
 32045   face_id = merge_glyphless_glyph_face (it);
 32046 
 32047   if (it->glyphless_method == GLYPHLESS_DISPLAY_THIN_SPACE)
 32048     {
 32049       it->pixel_width = THIN_SPACE_WIDTH;
 32050       len = 0;
 32051       upper_xoff = upper_yoff = lower_xoff = lower_yoff = 0;
 32052     }
 32053   else if (it->glyphless_method == GLYPHLESS_DISPLAY_EMPTY_BOX)
 32054     {
 32055       width = CHARACTER_WIDTH (it->c);
 32056       if (width == 0)
 32057         width = 1;
 32058       else if (width > 4)
 32059         width = 4;
 32060       it->pixel_width = base_width * width;
 32061       len = 0;
 32062       upper_xoff = upper_yoff = lower_xoff = lower_yoff = 0;
 32063     }
 32064   else
 32065     {
 32066       char buf[7];
 32067       const char *str;
 32068       unsigned int code[6];
 32069       int upper_len;
 32070       int ascent, descent;
 32071       struct font_metrics metrics_upper, metrics_lower;
 32072 
 32073       face = FACE_FROM_ID (it->f, face_id);
 32074       font = face->font ? face->font : FRAME_FONT (it->f);
 32075       prepare_face_for_display (it->f, face);
 32076 
 32077       if (it->glyphless_method == GLYPHLESS_DISPLAY_ACRONYM)
 32078         {
 32079           if (! STRINGP (acronym) && CHAR_TABLE_P (Vglyphless_char_display))
 32080             acronym = CHAR_TABLE_REF (Vglyphless_char_display, it->c);
 32081           if (CONSP (acronym))
 32082             acronym = XCAR (acronym);
 32083           str = STRINGP (acronym) ? SSDATA (acronym) : "";
 32084         }
 32085       else
 32086         {
 32087           eassert (it->glyphless_method == GLYPHLESS_DISPLAY_HEX_CODE);
 32088           sprintf (buf, "%0*X", it->c < 0x10000 ? 4 : 6, it->c + 0u);
 32089           str = buf;
 32090         }
 32091       for (len = 0; str[len] && ASCII_CHAR_P (str[len]) && len < 6; len++)
 32092         code[len] = font->driver->encode_char (font, str[len]);
 32093       upper_len = (len + 1) / 2;
 32094       font->driver->text_extents (font, code, upper_len,
 32095                                   &metrics_upper);
 32096       font->driver->text_extents (font, code + upper_len, len - upper_len,
 32097                                   &metrics_lower);
 32098 
 32099 
 32100 
 32101       /* +4 is for vertical bars of a box plus 1-pixel spaces at both side.  */
 32102       width = max (metrics_upper.width, metrics_lower.width) + 4;
 32103       upper_xoff = lower_xoff = 2; /* the typical case */
 32104       if (base_width >= width)
 32105         {
 32106           /* Align the upper to the left, the lower to the right.  */
 32107           it->pixel_width = base_width;
 32108           lower_xoff = base_width - 2 - metrics_lower.width;
 32109         }
 32110       else
 32111         {
 32112           /* Center the shorter one.  */
 32113           it->pixel_width = width;
 32114           if (metrics_upper.width >= metrics_lower.width)
 32115             lower_xoff = (width - metrics_lower.width) / 2;
 32116           else
 32117             upper_xoff = (width - metrics_upper.width) / 2;
 32118         }
 32119 
 32120       /* +5 is for horizontal bars of a box plus 1-pixel spaces at
 32121          top, bottom, and between upper and lower strings.  */
 32122       height = (metrics_upper.ascent + metrics_upper.descent
 32123                 + metrics_lower.ascent + metrics_lower.descent) + 5;
 32124       /* Center vertically.
 32125          H:base_height, D:base_descent
 32126          h:height, ld:lower_descent, la:lower_ascent, ud:upper_descent
 32127 
 32128          ascent = - (D - H/2 - h/2 + 1); "+ 1" for rounding up
 32129          descent = D - H/2 + h/2;
 32130          lower_yoff = descent - 2 - ld;
 32131          upper_yoff = lower_yoff - la - 1 - ud;  */
 32132       ascent = - (it->descent - (base_height + height + 1) / 2);
 32133       descent = it->descent - (base_height - height) / 2;
 32134       lower_yoff = descent - 2 - metrics_lower.descent;
 32135       upper_yoff = (lower_yoff - metrics_lower.ascent - 1
 32136                     - metrics_upper.descent);
 32137       /* Don't make the height shorter than the base height.  */
 32138       if (height > base_height)
 32139         {
 32140           it->ascent = ascent;
 32141           it->descent = descent;
 32142         }
 32143     }
 32144 
 32145   it->phys_ascent = it->ascent;
 32146   it->phys_descent = it->descent;
 32147   if (it->glyph_row)
 32148     append_glyphless_glyph (it, face_id, for_no_font, len,
 32149                             upper_xoff, upper_yoff,
 32150                             lower_xoff, lower_yoff);
 32151   it->nglyphs = 1;
 32152   take_vertical_position_into_account (it);
 32153 }
 32154 
 32155 
 32156 /* If face has a box, add the box thickness to the character
 32157    height.  If character has a box line to the left and/or
 32158    right, add the box line width to the character's width.  */
 32159 #define IT_APPLY_FACE_BOX(it, face)                             \
 32160   do {                                                          \
 32161     if (face->box != FACE_NO_BOX)                               \
 32162       {                                                         \
 32163         int thick = face->box_horizontal_line_width;            \
 32164         if (thick > 0)                                          \
 32165           {                                                     \
 32166             it->ascent += thick;                                \
 32167             it->descent += thick;                               \
 32168           }                                                     \
 32169                                                                 \
 32170         thick = face->box_vertical_line_width;                  \
 32171         if (thick > 0)                                          \
 32172           {                                                     \
 32173             if (it->start_of_box_run_p)                         \
 32174               it->pixel_width += thick;                         \
 32175             if (it->end_of_box_run_p)                           \
 32176               it->pixel_width += thick;                         \
 32177           }                                                     \
 32178       }                                                         \
 32179     } while (false)
 32180 
 32181 /* RIF:
 32182    Produce glyphs/get display metrics for the display element IT is
 32183    loaded with.  See the description of struct it in dispextern.h
 32184    for an overview of struct it.  */
 32185 
 32186 void
 32187 gui_produce_glyphs (struct it *it)
 32188 {
 32189   int extra_line_spacing = it->extra_line_spacing;
 32190 
 32191   it->glyph_not_available_p = false;
 32192 
 32193   if (it->what == IT_CHARACTER)
 32194     {
 32195       unsigned char2b;
 32196       struct face *face = FACE_FROM_ID (it->f, it->face_id);
 32197       struct font *font = face->font;
 32198       struct font_metrics *pcm = NULL;
 32199       int boff;                 /* Baseline offset.  */
 32200 
 32201       if (font == NULL)
 32202         {
 32203           /* When no suitable font is found, display this character by
 32204              the method specified in the first extra slot of
 32205              Vglyphless_char_display.  */
 32206           Lisp_Object acronym = lookup_glyphless_char_display (-1, it);
 32207 
 32208           eassert (it->what == IT_GLYPHLESS);
 32209           produce_glyphless_glyph (it, true,
 32210                                    STRINGP (acronym) ? acronym : Qnil);
 32211           goto done;
 32212         }
 32213 
 32214       boff = font->baseline_offset;
 32215       if (font->vertical_centering)
 32216         boff = VCENTER_BASELINE_OFFSET (font, it->f) - boff;
 32217 
 32218       if (it->char_to_display != '\n' && it->char_to_display != '\t')
 32219         {
 32220           it->nglyphs = 1;
 32221 
 32222           if (it->override_ascent >= 0)
 32223             {
 32224               it->ascent = it->override_ascent;
 32225               it->descent = it->override_descent;
 32226               boff = it->override_boff;
 32227             }
 32228           else
 32229             {
 32230               it->ascent = FONT_BASE (font) + boff;
 32231               it->descent = FONT_DESCENT (font) - boff;
 32232             }
 32233 
 32234           if (get_char_glyph_code (it->char_to_display, font, &char2b))
 32235             {
 32236               pcm = get_per_char_metric (font, &char2b);
 32237               if (pcm->width == 0
 32238                   && pcm->rbearing == 0 && pcm->lbearing == 0)
 32239                 pcm = NULL;
 32240             }
 32241 
 32242           if (pcm)
 32243             {
 32244               it->phys_ascent = pcm->ascent + boff;
 32245               it->phys_descent = pcm->descent - boff;
 32246               it->pixel_width = pcm->width;
 32247               /* Don't use font-global values for ascent and descent
 32248                  if they result in an exceedingly large line height.  */
 32249               if (it->override_ascent < 0)
 32250                 {
 32251                   if (FONT_TOO_HIGH (font))
 32252                     {
 32253                       it->ascent = it->phys_ascent;
 32254                       it->descent = it->phys_descent;
 32255                       /* These limitations are enforced by an
 32256                          assertion near the end of this function.  */
 32257                       if (it->ascent < 0)
 32258                         it->ascent = 0;
 32259                       if (it->descent < 0)
 32260                         it->descent = 0;
 32261                     }
 32262                 }
 32263             }
 32264           else
 32265             {
 32266               it->glyph_not_available_p = true;
 32267               it->phys_ascent = it->ascent;
 32268               it->phys_descent = it->descent;
 32269               it->pixel_width = font->space_width;
 32270             }
 32271 
 32272           if (it->constrain_row_ascent_descent_p)
 32273             {
 32274               if (it->descent > it->max_descent)
 32275                 {
 32276                   it->ascent += it->descent - it->max_descent;
 32277                   it->descent = it->max_descent;
 32278                 }
 32279               if (it->ascent > it->max_ascent)
 32280                 {
 32281                   it->descent = min (it->max_descent, it->descent + it->ascent - it->max_ascent);
 32282                   it->ascent = it->max_ascent;
 32283                 }
 32284               it->phys_ascent = min (it->phys_ascent, it->ascent);
 32285               it->phys_descent = min (it->phys_descent, it->descent);
 32286               extra_line_spacing = 0;
 32287             }
 32288 
 32289           /* If this is a space inside a region of text with
 32290              `space-width' property, change its width.  */
 32291           bool stretched_p
 32292             = it->char_to_display == ' ' && !NILP (it->space_width);
 32293           if (stretched_p)
 32294             it->pixel_width *= XFLOATINT (it->space_width);
 32295 
 32296           IT_APPLY_FACE_BOX(it, face);
 32297 
 32298           /* If face has an overline, add the height of the overline
 32299              (1 pixel) and a 1 pixel margin to the character height.  */
 32300           if (face->overline_p)
 32301             it->ascent += clip_to_bounds (0, overline_margin, 1000000);
 32302 
 32303           if (it->constrain_row_ascent_descent_p)
 32304             {
 32305               if (it->ascent > it->max_ascent)
 32306                 it->ascent = it->max_ascent;
 32307               if (it->descent > it->max_descent)
 32308                 it->descent = it->max_descent;
 32309             }
 32310 
 32311           take_vertical_position_into_account (it);
 32312 
 32313           /* If we have to actually produce glyphs, do it.  */
 32314           if (it->glyph_row)
 32315             {
 32316               if (stretched_p)
 32317                 {
 32318                   /* Translate a space with a `space-width' property
 32319                      into a stretch glyph.  */
 32320                   int ascent = (((it->ascent + it->descent) * FONT_BASE (font))
 32321                                 / FONT_HEIGHT (font));
 32322                   append_stretch_glyph (it, it->object, it->pixel_width,
 32323                                         it->ascent + it->descent, ascent);
 32324                 }
 32325               else
 32326                 append_glyph (it);
 32327 
 32328               /* If characters with lbearing or rbearing are displayed
 32329                  in this line, record that fact in a flag of the
 32330                  glyph row.  This is used to optimize X output code.  */
 32331               if (pcm && (pcm->lbearing < 0 || pcm->rbearing > pcm->width))
 32332                 it->glyph_row->contains_overlapping_glyphs_p = true;
 32333             }
 32334           if (! stretched_p && it->pixel_width == 0)
 32335             /* We assure that all visible glyphs have at least 1-pixel
 32336                width.  */
 32337             it->pixel_width = 1;
 32338         }
 32339       else if (it->char_to_display == '\n')
 32340         {
 32341           /* A newline has no width, but we need the height of the
 32342              line.  But if previous part of the line sets a height,
 32343              don't increase that height.  */
 32344 
 32345           Lisp_Object height;
 32346           Lisp_Object total_height = Qnil;
 32347 
 32348           it->override_ascent = -1;
 32349           it->pixel_width = 0;
 32350           it->nglyphs = 0;
 32351 
 32352           height = get_it_property (it, Qline_height);
 32353           /* Split (line-height total-height) list.  */
 32354           if (CONSP (height)
 32355               && CONSP (XCDR (height))
 32356               && NILP (XCDR (XCDR (height))))
 32357             {
 32358               total_height = XCAR (XCDR (height));
 32359               height = XCAR (height);
 32360             }
 32361           height = calc_line_height_property (it, height, font, boff, true);
 32362 
 32363           if (it->override_ascent >= 0)
 32364             {
 32365               it->ascent = it->override_ascent;
 32366               it->descent = it->override_descent;
 32367               boff = it->override_boff;
 32368             }
 32369           else
 32370             {
 32371               if (FONT_TOO_HIGH (font))
 32372                 {
 32373                   it->ascent = font->pixel_size + boff - 1;
 32374                   it->descent = -boff + 1;
 32375                   if (it->descent < 0)
 32376                     it->descent = 0;
 32377                 }
 32378               else
 32379                 {
 32380                   it->ascent = FONT_BASE (font) + boff;
 32381                   it->descent = FONT_DESCENT (font) - boff;
 32382                 }
 32383             }
 32384 
 32385           if (EQ (height, Qt))
 32386             {
 32387               if (it->descent > it->max_descent)
 32388                 {
 32389                   it->ascent += it->descent - it->max_descent;
 32390                   it->descent = it->max_descent;
 32391                 }
 32392               if (it->ascent > it->max_ascent)
 32393                 {
 32394                   it->descent = min (it->max_descent, it->descent + it->ascent - it->max_ascent);
 32395                   it->ascent = it->max_ascent;
 32396                 }
 32397               it->phys_ascent = min (it->phys_ascent, it->ascent);
 32398               it->phys_descent = min (it->phys_descent, it->descent);
 32399               it->constrain_row_ascent_descent_p = true;
 32400               extra_line_spacing = 0;
 32401             }
 32402           else
 32403             {
 32404               Lisp_Object spacing;
 32405 
 32406               it->phys_ascent = it->ascent;
 32407               it->phys_descent = it->descent;
 32408 
 32409               if ((it->max_ascent > 0 || it->max_descent > 0)
 32410                   && face->box != FACE_NO_BOX
 32411                   && face->box_horizontal_line_width > 0)
 32412                 {
 32413                   it->ascent += face->box_horizontal_line_width;
 32414                   it->descent += face->box_horizontal_line_width;
 32415                 }
 32416               if (!NILP (height)
 32417                   && XFIXNUM (height) > it->ascent + it->descent)
 32418                 it->ascent = XFIXNUM (height) - it->descent;
 32419 
 32420               if (!NILP (total_height))
 32421                 spacing = calc_line_height_property (it, total_height, font,
 32422                                                      boff, false);
 32423               else
 32424                 {
 32425                   spacing = get_it_property (it, Qline_spacing);
 32426                   spacing = calc_line_height_property (it, spacing, font,
 32427                                                        boff, false);
 32428                 }
 32429               if (FIXNUMP (spacing))
 32430                 {
 32431                   extra_line_spacing = XFIXNUM (spacing);
 32432                   if (!NILP (total_height))
 32433                     extra_line_spacing -= (it->phys_ascent + it->phys_descent);
 32434                 }
 32435             }
 32436         }
 32437       else                    /* i.e. (it->char_to_display == '\t') */
 32438         {
 32439           if (font->space_width > 0)
 32440             {
 32441               int tab_width = it->tab_width * font->space_width;
 32442               int x = it->current_x + it->continuation_lines_width;
 32443               int x0 = x;
 32444               /* Adjust for line numbers, if needed.   */
 32445               if (!NILP (Vdisplay_line_numbers) && it->line_number_produced_p)
 32446                 {
 32447                   x -= it->lnum_pixel_width;
 32448                   /* Restore the original TAB width, if required.  */
 32449                   if (x + it->stretch_adjust >= it->first_visible_x)
 32450                     x += it->stretch_adjust;
 32451                 }
 32452 
 32453               int next_tab_x = ((1 + x + tab_width - 1) / tab_width) * tab_width;
 32454 
 32455               /* If the distance from the current position to the next tab
 32456                  stop is less than a space character width, use the
 32457                  tab stop after that.  */
 32458               if (next_tab_x - x < font->space_width)
 32459                 next_tab_x += tab_width;
 32460               if (!NILP (Vdisplay_line_numbers) && it->line_number_produced_p)
 32461                 {
 32462                   next_tab_x += it->lnum_pixel_width;
 32463                   /* If the line is hscrolled, and the TAB starts before
 32464                      the first visible pixel, simulate negative row->x.  */
 32465                   if (x < it->first_visible_x)
 32466                     {
 32467                       next_tab_x -= it->first_visible_x - x;
 32468                       it->stretch_adjust = it->first_visible_x - x;
 32469                     }
 32470                   else
 32471                     next_tab_x -= it->stretch_adjust;
 32472                 }
 32473 
 32474               it->pixel_width = next_tab_x - x0;
 32475               it->nglyphs = 1;
 32476               if (FONT_TOO_HIGH (font))
 32477                 {
 32478                   if (get_char_glyph_code (' ', font, &char2b))
 32479                     {
 32480                       pcm = get_per_char_metric (font, &char2b);
 32481                       if (pcm->width == 0
 32482                           && pcm->rbearing == 0 && pcm->lbearing == 0)
 32483                         pcm = NULL;
 32484                     }
 32485 
 32486                   if (pcm)
 32487                     {
 32488                       it->ascent = pcm->ascent + boff;
 32489                       it->descent = pcm->descent - boff;
 32490                     }
 32491                   else
 32492                     {
 32493                       it->ascent = font->pixel_size + boff - 1;
 32494                       it->descent = -boff + 1;
 32495                     }
 32496                   if (it->ascent < 0)
 32497                     it->ascent = 0;
 32498                   if (it->descent < 0)
 32499                     it->descent = 0;
 32500                 }
 32501               else
 32502                 {
 32503                   it->ascent = FONT_BASE (font) + boff;
 32504                   it->descent = FONT_DESCENT (font) - boff;
 32505                 }
 32506               it->phys_ascent = it->ascent;
 32507               it->phys_descent = it->descent;
 32508 
 32509               if (it->glyph_row)
 32510                 {
 32511                   append_stretch_glyph (it, it->object, it->pixel_width,
 32512                                         it->ascent + it->descent, it->ascent);
 32513                 }
 32514             }
 32515           else
 32516             {
 32517               it->pixel_width = 0;
 32518               it->nglyphs = 1;
 32519             }
 32520         }
 32521 
 32522       if (FONT_TOO_HIGH (font))
 32523         {
 32524           int font_ascent, font_descent;
 32525 
 32526           /* For very large fonts, where we ignore the declared font
 32527              dimensions, and go by per-character metrics instead,
 32528              don't let the row ascent and descent values (and the row
 32529              height computed from them) be smaller than the "normal"
 32530              character metrics.  This avoids unpleasant effects
 32531              whereby lines on display would change their height
 32532              depending on which characters are shown.  */
 32533           normal_char_ascent_descent (font, -1, &font_ascent, &font_descent);
 32534           it->max_ascent = max (it->max_ascent, font_ascent);
 32535           it->max_descent = max (it->max_descent, font_descent);
 32536         }
 32537 
 32538       if (it->ascent < 0)
 32539         it->ascent = 0;
 32540       if (it->descent < 0)
 32541         it->descent = 0;
 32542     }
 32543   else if (it->what == IT_COMPOSITION && it->cmp_it.ch < 0)
 32544     {
 32545       /* A static composition.
 32546 
 32547          Note: A composition is represented as one glyph in the
 32548          glyph matrix.  There are no padding glyphs.
 32549 
 32550          Important note: pixel_width, ascent, and descent are the
 32551          values of what is drawn by draw_glyphs (i.e. the values of
 32552          the overall glyphs composed).  */
 32553       struct face *face = FACE_FROM_ID (it->f, it->face_id);
 32554       int boff;                 /* baseline offset */
 32555       struct composition *cmp = composition_table[it->cmp_it.id];
 32556       int glyph_len = cmp->glyph_len;
 32557       struct font *font = face->font;
 32558 
 32559       it->nglyphs = 1;
 32560 
 32561       /* If we have not yet calculated pixel size data of glyphs of
 32562          the composition for the current face font, calculate them
 32563          now.  Theoretically, we have to check all fonts for the
 32564          glyphs, but that requires much time and memory space.  So,
 32565          here we check only the font of the first glyph.  This may
 32566          lead to incorrect display, but it's very rare, and C-l
 32567          (recenter-top-bottom) can correct the display anyway.  */
 32568       if (! cmp->font || cmp->font != font)
 32569         {
 32570           /* Ascent and descent of the font of the first character
 32571              of this composition (adjusted by baseline offset).
 32572              Ascent and descent of overall glyphs should not be less
 32573              than these, respectively.  */
 32574           int font_ascent, font_descent, font_height;
 32575           /* Bounding box of the overall glyphs.  */
 32576           int leftmost, rightmost, lowest, highest;
 32577           int lbearing, rbearing;
 32578           int i, width, ascent, descent;
 32579           int c;
 32580           unsigned char2b;
 32581           struct font_metrics *pcm;
 32582           ptrdiff_t pos;
 32583 
 32584           eassume (0 < glyph_len); /* See Bug#8512.  */
 32585           do
 32586             c = COMPOSITION_GLYPH (cmp, glyph_len - 1);
 32587           while (c == '\t' && 0 < --glyph_len);
 32588 
 32589           bool right_padded = glyph_len < cmp->glyph_len;
 32590           for (i = 0; i < glyph_len; i++)
 32591             {
 32592               c = COMPOSITION_GLYPH (cmp, i);
 32593               if (c != '\t')
 32594                 break;
 32595               cmp->offsets[i * 2] = cmp->offsets[i * 2 + 1] = 0;
 32596             }
 32597           bool left_padded = i > 0;
 32598 
 32599           pos = (STRINGP (it->string) ? IT_STRING_CHARPOS (*it)
 32600                  : IT_CHARPOS (*it));
 32601           /* If no suitable font is found, use the default font.  */
 32602           bool font_not_found_p = font == NULL;
 32603           if (font_not_found_p)
 32604             {
 32605               face = face->ascii_face;
 32606               font = face->font;
 32607             }
 32608           boff = font->baseline_offset;
 32609           if (font->vertical_centering)
 32610             boff = VCENTER_BASELINE_OFFSET (font, it->f) - boff;
 32611           normal_char_ascent_descent (font, -1, &font_ascent, &font_descent);
 32612           font_ascent +=  boff;
 32613           font_descent -= boff;
 32614           font_height = font_ascent + font_descent;
 32615 
 32616           cmp->font = font;
 32617 
 32618           pcm = NULL;
 32619           if (! font_not_found_p)
 32620             {
 32621               get_char_face_and_encoding (it->f, c, it->face_id,
 32622                                           &char2b, false);
 32623               pcm = get_per_char_metric (font, &char2b);
 32624             }
 32625 
 32626           /* Initialize the bounding box.  */
 32627           if (pcm)
 32628             {
 32629               width = cmp->glyph_len > 0 ? pcm->width : 0;
 32630               ascent = pcm->ascent;
 32631               descent = pcm->descent;
 32632               lbearing = pcm->lbearing;
 32633               rbearing = pcm->rbearing;
 32634             }
 32635           else
 32636             {
 32637               width = cmp->glyph_len > 0 ? font->space_width : 0;
 32638               ascent = FONT_BASE (font);
 32639               descent = FONT_DESCENT (font);
 32640               lbearing = 0;
 32641               rbearing = width;
 32642             }
 32643 
 32644           rightmost = width;
 32645           leftmost = 0;
 32646           lowest = - descent + boff;
 32647           highest = ascent + boff;
 32648 
 32649           if (! font_not_found_p
 32650               && font->default_ascent
 32651               && CHAR_TABLE_P (Vuse_default_ascent)
 32652               && !NILP (Faref (Vuse_default_ascent,
 32653                                make_fixnum (it->char_to_display))))
 32654             highest = font->default_ascent + boff;
 32655 
 32656           /* Draw the first glyph at the normal position.  It may be
 32657              shifted to right later if some other glyphs are drawn
 32658              at the left.  */
 32659           cmp->offsets[i * 2] = 0;
 32660           cmp->offsets[i * 2 + 1] = boff;
 32661           cmp->lbearing = lbearing;
 32662           cmp->rbearing = rbearing;
 32663 
 32664           /* Set cmp->offsets for the remaining glyphs.  */
 32665           for (i++; i < glyph_len; i++)
 32666             {
 32667               int left, right, btm, top;
 32668               int ch = COMPOSITION_GLYPH (cmp, i);
 32669               int face_id;
 32670               struct face *this_face;
 32671 
 32672               if (ch == '\t')
 32673                 ch = ' ';
 32674               face_id = FACE_FOR_CHAR (it->f, face, ch, pos, it->string);
 32675               this_face = FACE_FROM_ID (it->f, face_id);
 32676               font = this_face->font;
 32677 
 32678               if (font == NULL)
 32679                 pcm = NULL;
 32680               else
 32681                 {
 32682                   get_char_face_and_encoding (it->f, ch, face_id,
 32683                                               &char2b, false);
 32684                   pcm = get_per_char_metric (font, &char2b);
 32685                 }
 32686               if (! pcm)
 32687                 cmp->offsets[i * 2] = cmp->offsets[i * 2 + 1] = 0;
 32688               else
 32689                 {
 32690                   width = pcm->width;
 32691                   ascent = pcm->ascent;
 32692                   descent = pcm->descent;
 32693                   lbearing = pcm->lbearing;
 32694                   rbearing = pcm->rbearing;
 32695                   if (cmp->method != COMPOSITION_WITH_RULE_ALTCHARS)
 32696                     {
 32697                       /* Relative composition with or without
 32698                          alternate chars.  */
 32699                       left = (leftmost + rightmost - width) / 2;
 32700                       btm = - descent + boff;
 32701                       if (font->relative_compose
 32702                           && (! CHAR_TABLE_P (Vignore_relative_composition)
 32703                               || NILP (Faref (Vignore_relative_composition,
 32704                                               make_fixnum (ch)))))
 32705                         {
 32706 
 32707                           if (- descent >= font->relative_compose)
 32708                             /* One extra pixel between two glyphs.  */
 32709                             btm = highest + 1;
 32710                           else if (ascent <= 0)
 32711                             /* One extra pixel between two glyphs.  */
 32712                             btm = lowest - 1 - ascent - descent;
 32713                         }
 32714                     }
 32715                   else
 32716                     {
 32717                       /* A composition rule is specified by an integer
 32718                          value that encodes global and new reference
 32719                          points (GREF and NREF).  GREF and NREF are
 32720                          specified by numbers as below:
 32721 
 32722                          0---1---2 -- ascent
 32723                          |       |
 32724                          |       |
 32725                          |       |
 32726                          9--10--11 -- center
 32727                          |       |
 32728                          ---3---4---5--- baseline
 32729                          |       |
 32730                          6---7---8 -- descent
 32731                       */
 32732                       int rule = COMPOSITION_RULE (cmp, i);
 32733                       int gref, nref, grefx, grefy, nrefx, nrefy, xoff, yoff;
 32734 
 32735                       COMPOSITION_DECODE_RULE (rule, gref, nref, xoff, yoff);
 32736                       grefx = gref % 3, nrefx = nref % 3;
 32737                       grefy = gref / 3, nrefy = nref / 3;
 32738                       if (xoff)
 32739                         xoff = font_height * (xoff - 128) / 256;
 32740                       if (yoff)
 32741                         yoff = font_height * (yoff - 128) / 256;
 32742 
 32743                       left = (leftmost
 32744                               + grefx * (rightmost - leftmost) / 2
 32745                               - nrefx * width / 2
 32746                               + xoff);
 32747 
 32748                       btm = ((grefy == 0 ? highest
 32749                               : grefy == 1 ? 0
 32750                               : grefy == 2 ? lowest
 32751                               : (highest + lowest) / 2)
 32752                              - (nrefy == 0 ? ascent + descent
 32753                                 : nrefy == 1 ? descent - boff
 32754                                 : nrefy == 2 ? 0
 32755                                 : (ascent + descent) / 2)
 32756                              + yoff);
 32757                     }
 32758 
 32759                   cmp->offsets[i * 2] = left;
 32760                   cmp->offsets[i * 2 + 1] = btm + descent;
 32761 
 32762                   /* Update the bounding box of the overall glyphs. */
 32763                   if (width > 0)
 32764                     {
 32765                       right = left + width;
 32766                       if (left < leftmost)
 32767                         leftmost = left;
 32768                       if (right > rightmost)
 32769                         rightmost = right;
 32770                     }
 32771                   top = btm + descent + ascent;
 32772                   if (top > highest)
 32773                     highest = top;
 32774                   if (btm < lowest)
 32775                     lowest = btm;
 32776 
 32777                   if (cmp->lbearing > left + lbearing)
 32778                     cmp->lbearing = left + lbearing;
 32779                   if (cmp->rbearing < left + rbearing)
 32780                     cmp->rbearing = left + rbearing;
 32781                 }
 32782             }
 32783 
 32784           /* If there are glyphs whose x-offsets are negative,
 32785              shift all glyphs to the right and make all x-offsets
 32786              non-negative.  */
 32787           if (leftmost < 0)
 32788             {
 32789               for (i = 0; i < cmp->glyph_len; i++)
 32790                 cmp->offsets[i * 2] -= leftmost;
 32791               rightmost -= leftmost;
 32792               cmp->lbearing -= leftmost;
 32793               cmp->rbearing -= leftmost;
 32794             }
 32795 
 32796           if (left_padded && cmp->lbearing < 0)
 32797             {
 32798               for (i = 0; i < cmp->glyph_len; i++)
 32799                 cmp->offsets[i * 2] -= cmp->lbearing;
 32800               rightmost -= cmp->lbearing;
 32801               cmp->rbearing -= cmp->lbearing;
 32802               cmp->lbearing = 0;
 32803             }
 32804           if (right_padded && rightmost < cmp->rbearing)
 32805             {
 32806               rightmost = cmp->rbearing;
 32807             }
 32808 
 32809           cmp->pixel_width = rightmost;
 32810           cmp->ascent = highest;
 32811           cmp->descent = - lowest;
 32812           if (cmp->ascent < font_ascent)
 32813             cmp->ascent = font_ascent;
 32814           if (cmp->descent < font_descent)
 32815             cmp->descent = font_descent;
 32816         }
 32817 
 32818       if (it->glyph_row
 32819           && (cmp->lbearing < 0
 32820               || cmp->rbearing > cmp->pixel_width))
 32821         it->glyph_row->contains_overlapping_glyphs_p = true;
 32822 
 32823       it->pixel_width = cmp->pixel_width;
 32824       it->ascent = it->phys_ascent = cmp->ascent;
 32825       it->descent = it->phys_descent = cmp->descent;
 32826       IT_APPLY_FACE_BOX(it, face);
 32827 
 32828       /* If face has an overline, add the height of the overline
 32829          (1 pixel) and a 1 pixel margin to the character height.  */
 32830       if (face->overline_p)
 32831         it->ascent += clip_to_bounds (0, overline_margin, 1000000);
 32832 
 32833       take_vertical_position_into_account (it);
 32834       if (it->ascent < 0)
 32835         it->ascent = 0;
 32836       if (it->descent < 0)
 32837         it->descent = 0;
 32838 
 32839       if (it->glyph_row && cmp->glyph_len > 0)
 32840         append_composite_glyph (it);
 32841     }
 32842   else if (it->what == IT_COMPOSITION)
 32843     {
 32844       /* A dynamic (automatic) composition.  */
 32845       struct face *face = FACE_FROM_ID (it->f, it->face_id);
 32846       Lisp_Object gstring;
 32847       struct font_metrics metrics;
 32848 
 32849       it->nglyphs = 1;
 32850 
 32851       gstring = composition_gstring_from_id (it->cmp_it.id);
 32852       it->pixel_width
 32853         = composition_gstring_width (gstring, it->cmp_it.from, it->cmp_it.to,
 32854                                      &metrics);
 32855       if (it->pixel_width == 0)
 32856         {
 32857           it->glyph_not_available_p = true;
 32858           it->phys_ascent = it->ascent;
 32859           it->phys_descent = it->descent;
 32860           it->pixel_width = face->font->space_width;
 32861         }
 32862       else
 32863         {
 32864           if (it->glyph_row
 32865               && (metrics.lbearing < 0 || metrics.rbearing > metrics.width))
 32866             it->glyph_row->contains_overlapping_glyphs_p = true;
 32867           it->ascent = it->phys_ascent = metrics.ascent;
 32868           it->descent = it->phys_descent = metrics.descent;
 32869         }
 32870       IT_APPLY_FACE_BOX(it, face);
 32871 
 32872       /* If face has an overline, add the height of the overline
 32873          (1 pixel) and a 1 pixel margin to the character height.  */
 32874       if (face->overline_p)
 32875         it->ascent += clip_to_bounds (0, overline_margin, 1000000);
 32876       take_vertical_position_into_account (it);
 32877       if (it->ascent < 0)
 32878         it->ascent = 0;
 32879       if (it->descent < 0)
 32880         it->descent = 0;
 32881 
 32882       if (it->glyph_row)
 32883         append_composite_glyph (it);
 32884     }
 32885   else if (it->what == IT_GLYPHLESS)
 32886     produce_glyphless_glyph (it, false, Qnil);
 32887   else if (it->what == IT_IMAGE)
 32888     produce_image_glyph (it);
 32889   else if (it->what == IT_STRETCH)
 32890     produce_stretch_glyph (it);
 32891   else if (it->what == IT_XWIDGET)
 32892     produce_xwidget_glyph (it);
 32893 
 32894  done:
 32895   /* Accumulate dimensions.  Note: can't assume that it->descent > 0
 32896      because this isn't true for images with `:ascent 100'.  */
 32897   eassert (it->ascent >= 0 && it->descent >= 0);
 32898   if (it->area == TEXT_AREA)
 32899     it->current_x += it->pixel_width;
 32900 
 32901   if (extra_line_spacing > 0)
 32902     {
 32903       it->descent += extra_line_spacing;
 32904       if (extra_line_spacing > it->max_extra_line_spacing)
 32905         it->max_extra_line_spacing = extra_line_spacing;
 32906     }
 32907 
 32908   it->max_ascent = max (it->max_ascent, it->ascent);
 32909   it->max_descent = max (it->max_descent, it->descent);
 32910   it->max_phys_ascent = max (it->max_phys_ascent, it->phys_ascent);
 32911   it->max_phys_descent = max (it->max_phys_descent, it->phys_descent);
 32912 }
 32913 
 32914 /* EXPORT for RIF:
 32915    Output LEN glyphs starting at START at the nominal cursor position.
 32916    Advance the nominal cursor over the text.  UPDATED_ROW is the glyph row
 32917    being updated, and UPDATED_AREA is the area of that row being updated.  */
 32918 
 32919 void
 32920 gui_write_glyphs (struct window *w, struct glyph_row *updated_row,
 32921                 struct glyph *start, enum glyph_row_area updated_area, int len)
 32922 {
 32923   int x, hpos, chpos = w->phys_cursor.hpos;
 32924 
 32925   eassert (updated_row);
 32926   /* When the window is hscrolled, cursor hpos can legitimately be out
 32927      of bounds, but we draw the cursor at the corresponding window
 32928      margin in that case.  */
 32929   if (!updated_row->reversed_p && chpos < 0)
 32930     chpos = 0;
 32931   if (updated_row->reversed_p && chpos >= updated_row->used[TEXT_AREA])
 32932     chpos = updated_row->used[TEXT_AREA] - 1;
 32933 
 32934   block_input ();
 32935 
 32936   /* Write glyphs.  */
 32937 
 32938   hpos = start - updated_row->glyphs[updated_area];
 32939   x = draw_glyphs (w, w->output_cursor.x,
 32940                    updated_row, updated_area,
 32941                    hpos, hpos + len,
 32942                    DRAW_NORMAL_TEXT, 0);
 32943 
 32944   /* Invalidate old phys cursor if the glyph at its hpos is redrawn.  */
 32945   if (updated_area == TEXT_AREA
 32946       && w->phys_cursor_on_p
 32947       && w->phys_cursor.vpos == w->output_cursor.vpos
 32948       && chpos >= hpos
 32949       && chpos < hpos + len)
 32950     w->phys_cursor_on_p = false;
 32951 
 32952   unblock_input ();
 32953 
 32954   /* Advance the output cursor.  */
 32955   w->output_cursor.hpos += len;
 32956   w->output_cursor.x = x;
 32957 }
 32958 
 32959 
 32960 /* EXPORT for RIF:
 32961    Insert LEN glyphs from START at the nominal cursor position.  */
 32962 
 32963 void
 32964 gui_insert_glyphs (struct window *w, struct glyph_row *updated_row,
 32965                  struct glyph *start, enum glyph_row_area updated_area, int len)
 32966 {
 32967   struct frame *f;
 32968   int line_height, shift_by_width, shifted_region_width;
 32969   struct glyph_row *row;
 32970   struct glyph *glyph;
 32971   int frame_x, frame_y;
 32972   ptrdiff_t hpos;
 32973 
 32974   eassert (updated_row);
 32975   block_input ();
 32976   f = XFRAME (WINDOW_FRAME (w));
 32977 
 32978   /* Get the height of the line we are in.  */
 32979   row = updated_row;
 32980   line_height = row->height;
 32981 
 32982   /* Get the width of the glyphs to insert.  */
 32983   shift_by_width = 0;
 32984   for (glyph = start; glyph < start + len; ++glyph)
 32985     shift_by_width += glyph->pixel_width;
 32986 
 32987   /* Get the width of the region to shift right.  */
 32988   shifted_region_width = (window_box_width (w, updated_area)
 32989                           - w->output_cursor.x
 32990                           - shift_by_width);
 32991 
 32992   /* Shift right.  */
 32993   frame_x = window_box_left (w, updated_area) + w->output_cursor.x;
 32994   frame_y = WINDOW_TO_FRAME_PIXEL_Y (w, w->output_cursor.y);
 32995 
 32996   FRAME_RIF (f)->shift_glyphs_for_insert (f, frame_x, frame_y, shifted_region_width,
 32997                                           line_height, shift_by_width);
 32998 
 32999   /* Write the glyphs.  */
 33000   hpos = start - row->glyphs[updated_area];
 33001   draw_glyphs (w, w->output_cursor.x, row, updated_area,
 33002                hpos, hpos + len,
 33003                DRAW_NORMAL_TEXT, 0);
 33004 
 33005   /* Advance the output cursor.  */
 33006   w->output_cursor.hpos += len;
 33007   w->output_cursor.x += shift_by_width;
 33008   unblock_input ();
 33009 }
 33010 
 33011 
 33012 /* EXPORT for RIF:
 33013    Erase the current text line from the nominal cursor position
 33014    (inclusive) to pixel column TO_X (exclusive).  The idea is that
 33015    everything from TO_X onward is already erased.
 33016 
 33017    TO_X is a pixel position relative to UPDATED_AREA of currently
 33018    updated window W.  TO_X == -1 means clear to the end of this area.  */
 33019 
 33020 void
 33021 gui_clear_end_of_line (struct window *w, struct glyph_row *updated_row,
 33022                        enum glyph_row_area updated_area, int to_x)
 33023 {
 33024   struct frame *f;
 33025   int max_x, min_y, max_y;
 33026   int from_x, from_y, to_y;
 33027   struct face *face;
 33028 
 33029   eassert (updated_row);
 33030   f = XFRAME (w->frame);
 33031   face = FACE_FROM_ID_OR_NULL (f, DEFAULT_FACE_ID);
 33032 
 33033   if (updated_row->full_width_p)
 33034     max_x = (WINDOW_PIXEL_WIDTH (w)
 33035              - (updated_row->mode_line_p ? WINDOW_RIGHT_DIVIDER_WIDTH (w) : 0));
 33036   else
 33037     max_x = window_box_width (w, updated_area);
 33038   max_y = window_text_bottom_y (w);
 33039 
 33040   /* TO_X == 0 means don't do anything.  TO_X < 0 means clear to end
 33041      of window.  For TO_X > 0, truncate to end of drawing area.  */
 33042   if (to_x == 0)
 33043     return;
 33044   else if (to_x < 0)
 33045     to_x = max_x;
 33046   else
 33047     to_x = min (to_x, max_x);
 33048 
 33049   to_y = min (max_y, w->output_cursor.y + updated_row->height);
 33050 
 33051   /* Notice if the cursor will be cleared by this operation.  */
 33052   if (!updated_row->full_width_p)
 33053     notice_overwritten_cursor (w, updated_area,
 33054                                w->output_cursor.x, -1,
 33055                                updated_row->y,
 33056                                MATRIX_ROW_BOTTOM_Y (updated_row));
 33057 
 33058   from_x = w->output_cursor.x;
 33059 
 33060   /* Translate to frame coordinates.  */
 33061   if (updated_row->full_width_p)
 33062     {
 33063       from_x = WINDOW_TO_FRAME_PIXEL_X (w, from_x);
 33064       to_x = WINDOW_TO_FRAME_PIXEL_X (w, to_x);
 33065     }
 33066   else
 33067     {
 33068       int area_left = window_box_left (w, updated_area);
 33069       from_x += area_left;
 33070       to_x += area_left;
 33071     }
 33072 
 33073   min_y = WINDOW_TAB_LINE_HEIGHT (w) + WINDOW_HEADER_LINE_HEIGHT (w);
 33074   from_y = WINDOW_TO_FRAME_PIXEL_Y (w, max (min_y, w->output_cursor.y));
 33075   to_y = WINDOW_TO_FRAME_PIXEL_Y (w, to_y);
 33076 
 33077   /* Prevent inadvertently clearing to end of the X window.  */
 33078   if (to_x > from_x && to_y > from_y)
 33079     {
 33080       block_input ();
 33081       FRAME_RIF (f)->clear_frame_area (f, from_x, from_y,
 33082                                        to_x - from_x, to_y - from_y);
 33083 
 33084       if (face && !updated_row->stipple_p)
 33085         updated_row->stipple_p = face->stipple;
 33086       unblock_input ();
 33087     }
 33088 }
 33089 
 33090 #endif /* HAVE_WINDOW_SYSTEM */
 33091 
 33092 
 33093 
 33094 /***********************************************************************
 33095                              Cursor types
 33096  ***********************************************************************/
 33097 
 33098 /* Value is the internal representation of the specified cursor type
 33099    ARG.  If type is BAR_CURSOR, return in *WIDTH the specified width
 33100    of the bar cursor.  */
 33101 
 33102 static enum text_cursor_kinds
 33103 get_specified_cursor_type (Lisp_Object arg, int *width)
 33104 {
 33105   enum text_cursor_kinds type;
 33106 
 33107   if (NILP (arg))
 33108     return NO_CURSOR;
 33109 
 33110   if (EQ (arg, Qbox))
 33111     return FILLED_BOX_CURSOR;
 33112 
 33113   if (EQ (arg, Qhollow))
 33114     return HOLLOW_BOX_CURSOR;
 33115 
 33116   if (EQ (arg, Qbar))
 33117     {
 33118       *width = 2;
 33119       return BAR_CURSOR;
 33120     }
 33121 
 33122   if (EQ (arg, Qhbar))
 33123     {
 33124       *width = 2;
 33125       return HBAR_CURSOR;
 33126     }
 33127 
 33128   if (CONSP (arg)
 33129       && RANGED_FIXNUMP (0, XCDR (arg), INT_MAX))
 33130     {
 33131       *width = XFIXNUM (XCDR (arg));
 33132 
 33133       if (EQ (XCAR (arg), Qbox))
 33134           return FILLED_BOX_CURSOR;
 33135       else if (EQ (XCAR (arg), Qbar))
 33136           return BAR_CURSOR;
 33137       else if (EQ (XCAR (arg), Qhbar))
 33138           return HBAR_CURSOR;
 33139     }
 33140 
 33141   /* Treat anything unknown as "hollow box cursor".
 33142      It was bad to signal an error; people have trouble fixing
 33143      .Xdefaults with Emacs, when it has something bad in it.  */
 33144   type = HOLLOW_BOX_CURSOR;
 33145 
 33146   return type;
 33147 }
 33148 
 33149 /* Set the default cursor types for specified frame.  */
 33150 void
 33151 set_frame_cursor_types (struct frame *f, Lisp_Object arg)
 33152 {
 33153   int width = 1;
 33154   Lisp_Object tem;
 33155 
 33156   FRAME_DESIRED_CURSOR (f) = get_specified_cursor_type (arg, &width);
 33157   FRAME_CURSOR_WIDTH (f) = width;
 33158 
 33159   /* By default, set up the blink-off state depending on the on-state.  */
 33160 
 33161   tem = Fassoc (arg, Vblink_cursor_alist, Qnil);
 33162   if (!NILP (tem))
 33163     {
 33164       FRAME_BLINK_OFF_CURSOR (f)
 33165         = get_specified_cursor_type (XCDR (tem), &width);
 33166       FRAME_BLINK_OFF_CURSOR_WIDTH (f) = width;
 33167     }
 33168   else
 33169     FRAME_BLINK_OFF_CURSOR (f) = DEFAULT_CURSOR;
 33170 
 33171   /* Make sure the cursor gets redrawn.  */
 33172   f->cursor_type_changed = true;
 33173 }
 33174 
 33175 
 33176 #ifdef HAVE_WINDOW_SYSTEM
 33177 
 33178 /* Return the cursor we want to be displayed in window W.  Return
 33179    width of bar/hbar cursor through WIDTH arg.  Return with
 33180    ACTIVE_CURSOR arg set to true if cursor in window W is `active'
 33181    (i.e. if the `system caret' should track this cursor).
 33182 
 33183    In a mini-buffer window, we want the cursor only to appear if we
 33184    are reading input from this window.  For the selected window, we
 33185    want the cursor type given by the frame parameter or buffer local
 33186    setting of cursor-type.  If explicitly marked off, draw no cursor.
 33187    In all other cases, we want a hollow box cursor.  */
 33188 
 33189 static enum text_cursor_kinds
 33190 get_window_cursor_type (struct window *w, struct glyph *glyph, int *width,
 33191                         bool *active_cursor)
 33192 {
 33193   struct frame *f = XFRAME (w->frame);
 33194   struct buffer *b = XBUFFER (w->contents);
 33195   int cursor_type = DEFAULT_CURSOR;
 33196   Lisp_Object alt_cursor;
 33197   bool non_selected = false;
 33198 
 33199   *active_cursor = true;
 33200 
 33201   /* Echo area */
 33202   if (cursor_in_echo_area
 33203       && FRAME_HAS_MINIBUF_P (f)
 33204       && EQ (FRAME_MINIBUF_WINDOW (f), echo_area_window))
 33205     {
 33206       if (w == XWINDOW (echo_area_window))
 33207         {
 33208           if (EQ (BVAR (b, cursor_type), Qt) || NILP (BVAR (b, cursor_type)))
 33209             {
 33210               *width = FRAME_CURSOR_WIDTH (f);
 33211               return FRAME_DESIRED_CURSOR (f);
 33212             }
 33213           else
 33214             return get_specified_cursor_type (BVAR (b, cursor_type), width);
 33215         }
 33216 
 33217       *active_cursor = false;
 33218       non_selected = true;
 33219     }
 33220 
 33221   /* Detect a nonselected window or nonselected frame.  */
 33222   else if (w != XWINDOW (f->selected_window)
 33223            || f != FRAME_DISPLAY_INFO (f)->highlight_frame)
 33224     {
 33225       *active_cursor = false;
 33226 
 33227       if (MINI_WINDOW_P (w) &&
 33228           (minibuf_level == 0
 33229            || is_minibuffer (0, w->contents)))
 33230         return NO_CURSOR;
 33231 
 33232       non_selected = true;
 33233     }
 33234 
 33235   /* Never display a cursor in a window in which cursor-type is nil.  */
 33236   if (NILP (BVAR (b, cursor_type)))
 33237     return NO_CURSOR;
 33238 
 33239   /* Get the normal cursor type for this window.  */
 33240   if (EQ (BVAR (b, cursor_type), Qt))
 33241     {
 33242       cursor_type = FRAME_DESIRED_CURSOR (f);
 33243       *width = FRAME_CURSOR_WIDTH (f);
 33244     }
 33245   else
 33246     cursor_type = get_specified_cursor_type (BVAR (b, cursor_type), width);
 33247 
 33248   /* Use cursor-in-non-selected-windows instead
 33249      for non-selected window or frame.  */
 33250   if (non_selected)
 33251     {
 33252       alt_cursor = BVAR (b, cursor_in_non_selected_windows);
 33253       if (!EQ (Qt, alt_cursor))
 33254         return get_specified_cursor_type (alt_cursor, width);
 33255       /* t means modify the normal cursor type.  */
 33256       if (cursor_type == FILLED_BOX_CURSOR)
 33257         cursor_type = HOLLOW_BOX_CURSOR;
 33258       else if (cursor_type == BAR_CURSOR && *width > 1)
 33259         --*width;
 33260       return cursor_type;
 33261     }
 33262 
 33263   /* Use normal cursor if not blinked off.  */
 33264   if (!w->cursor_off_p)
 33265     {
 33266       if (glyph != NULL && glyph->type == XWIDGET_GLYPH)
 33267         return NO_CURSOR;
 33268       if (glyph != NULL && glyph->type == IMAGE_GLYPH)
 33269         {
 33270           if (cursor_type == FILLED_BOX_CURSOR)
 33271             {
 33272               /* Using a block cursor on large images can be very
 33273                  annoying.  So use a hollow cursor for "large" images.
 33274                  If image is not transparent (no mask), also use
 33275                  hollow cursor.  */
 33276               struct image *img = IMAGE_OPT_FROM_ID (f, glyph->u.img_id);
 33277               if (img != NULL && IMAGEP (img->spec))
 33278                 {
 33279                   /* Interpret "large" as >SIZExSIZE and >NxN where
 33280                      SIZE is the value from cursor-type of the form
 33281                      (box . SIZE), where N = size of default frame
 33282                      font size.  So, setting cursor-type to (box . 32)
 33283                      should cover most of the "tiny" icons people may
 33284                      use.  */
 33285                   if (!img->mask
 33286                       || (CONSP (BVAR (b, cursor_type))
 33287                           && img->width > max (*width, WINDOW_FRAME_COLUMN_WIDTH (w))
 33288                           && img->height > max (*width, WINDOW_FRAME_LINE_HEIGHT (w))))
 33289                     cursor_type = HOLLOW_BOX_CURSOR;
 33290                 }
 33291             }
 33292           else if (cursor_type != NO_CURSOR)
 33293             {
 33294               /* Display current only supports BOX and HOLLOW cursors for images.
 33295                  So for now, unconditionally use a HOLLOW cursor when cursor is
 33296                  not a solid box cursor.  */
 33297               cursor_type = HOLLOW_BOX_CURSOR;
 33298             }
 33299       }
 33300       return cursor_type;
 33301     }
 33302 
 33303   /* Cursor is blinked off, so determine how to "toggle" it.  */
 33304 
 33305   /* First look for an entry matching the buffer's cursor-type in blink-cursor-alist.  */
 33306   if ((alt_cursor = Fassoc (BVAR (b, cursor_type), Vblink_cursor_alist, Qnil), !NILP (alt_cursor)))
 33307     return get_specified_cursor_type (XCDR (alt_cursor), width);
 33308 
 33309   /* Then see if frame has specified a specific blink off cursor type.  */
 33310   if (FRAME_BLINK_OFF_CURSOR (f) != DEFAULT_CURSOR)
 33311     {
 33312       *width = FRAME_BLINK_OFF_CURSOR_WIDTH (f);
 33313       return FRAME_BLINK_OFF_CURSOR (f);
 33314     }
 33315 
 33316 #if false
 33317   /* Some people liked having a permanently visible blinking cursor,
 33318      while others had very strong opinions against it.  So it was
 33319      decided to remove it.  KFS 2003-09-03 */
 33320 
 33321   /* Finally perform built-in cursor blinking:
 33322        filled box      <->   hollow box
 33323        wide [h]bar     <->   narrow [h]bar
 33324        narrow [h]bar   <->   no cursor
 33325        other type      <->   no cursor  */
 33326 
 33327   if (cursor_type == FILLED_BOX_CURSOR)
 33328     return HOLLOW_BOX_CURSOR;
 33329 
 33330   if ((cursor_type == BAR_CURSOR || cursor_type == HBAR_CURSOR) && *width > 1)
 33331     {
 33332       *width = 1;
 33333       return cursor_type;
 33334     }
 33335 #endif
 33336 
 33337   return NO_CURSOR;
 33338 }
 33339 
 33340 
 33341 /* Notice when the text cursor of window W has been completely
 33342    overwritten by a drawing operation that outputs glyphs in AREA
 33343    starting at X0 and ending at X1 in the line starting at Y0 and
 33344    ending at Y1.  X coordinates are area-relative.  X1 < 0 means all
 33345    the rest of the line after X0 has been written.  Y coordinates
 33346    are window-relative.  */
 33347 
 33348 static void
 33349 notice_overwritten_cursor (struct window *w, enum glyph_row_area area,
 33350                            int x0, int x1, int y0, int y1)
 33351 {
 33352   int cx0, cx1, cy0, cy1;
 33353   struct glyph_row *row;
 33354 
 33355   if (!w->phys_cursor_on_p)
 33356     return;
 33357   if (area != TEXT_AREA)
 33358     return;
 33359 
 33360   if (w->phys_cursor.vpos < 0
 33361       || w->phys_cursor.vpos >= w->current_matrix->nrows
 33362       || (row = w->current_matrix->rows + w->phys_cursor.vpos,
 33363           !(row->enabled_p && MATRIX_ROW_DISPLAYS_TEXT_P (row))))
 33364     return;
 33365 
 33366   if (row->cursor_in_fringe_p)
 33367     {
 33368       row->cursor_in_fringe_p = false;
 33369       draw_fringe_bitmap (w, row, row->reversed_p);
 33370       w->phys_cursor_on_p = false;
 33371       return;
 33372     }
 33373 
 33374   cx0 = w->phys_cursor.x;
 33375   cx1 = cx0 + w->phys_cursor_width;
 33376   if (x0 > cx0 || (x1 >= 0 && x1 < cx1))
 33377     return;
 33378 
 33379   /* The cursor image will be completely removed from the
 33380      screen if the output area intersects the cursor area in
 33381      y-direction.  When we draw in [y0 y1[, and some part of
 33382      the cursor is at y < y0, that part must have been drawn
 33383      before.  When scrolling, the cursor is erased before
 33384      actually scrolling, so we don't come here.  When not
 33385      scrolling, the rows above the old cursor row must have
 33386      changed, and in this case these rows must have written
 33387      over the cursor image.
 33388 
 33389      Likewise if part of the cursor is below y1, with the
 33390      exception of the cursor being in the first blank row at
 33391      the buffer and window end because update_text_area
 33392      doesn't draw that row.  (Except when it does, but
 33393      that's handled in update_text_area.)  */
 33394 
 33395   cy0 = w->phys_cursor.y;
 33396   cy1 = cy0 + w->phys_cursor_height;
 33397   if ((y0 < cy0 || y0 >= cy1) && (y1 <= cy0 || y1 >= cy1))
 33398     return;
 33399 
 33400   w->phys_cursor_on_p = false;
 33401 }
 33402 
 33403 #endif /* HAVE_WINDOW_SYSTEM */
 33404 
 33405 
 33406 /************************************************************************
 33407                               Mouse Face
 33408  ************************************************************************/
 33409 
 33410 #ifdef HAVE_WINDOW_SYSTEM
 33411 
 33412 /* EXPORT for RIF:
 33413    Fix the display of area AREA of overlapping row ROW in window W
 33414    with respect to the overlapping part OVERLAPS.  */
 33415 
 33416 void
 33417 gui_fix_overlapping_area (struct window *w, struct glyph_row *row,
 33418                         enum glyph_row_area area, int overlaps)
 33419 {
 33420   int i, x;
 33421 
 33422   block_input ();
 33423 
 33424   x = 0;
 33425   for (i = 0; i < row->used[area];)
 33426     {
 33427       if (row->glyphs[area][i].overlaps_vertically_p)
 33428         {
 33429           int start = i, start_x = x;
 33430 
 33431           do
 33432             {
 33433               x += row->glyphs[area][i].pixel_width;
 33434               ++i;
 33435             }
 33436           while (i < row->used[area]
 33437                  && row->glyphs[area][i].overlaps_vertically_p);
 33438 
 33439           draw_glyphs (w, start_x, row, area,
 33440                        start, i,
 33441                        DRAW_NORMAL_TEXT, overlaps);
 33442         }
 33443       else
 33444         {
 33445           x += row->glyphs[area][i].pixel_width;
 33446           ++i;
 33447         }
 33448     }
 33449 
 33450   unblock_input ();
 33451 }
 33452 
 33453 
 33454 /* EXPORT:
 33455    Draw the cursor glyph of window W in glyph row ROW.  See the
 33456    comment of draw_glyphs for the meaning of HL.  */
 33457 
 33458 void
 33459 draw_phys_cursor_glyph (struct window *w, struct glyph_row *row,
 33460                         enum draw_glyphs_face hl)
 33461 {
 33462   /* If cursor hpos is out of bounds, don't draw garbage.  This can
 33463      happen in mini-buffer windows when switching between echo area
 33464      glyphs and mini-buffer.  */
 33465   if ((row->reversed_p
 33466        ? (w->phys_cursor.hpos >= 0)
 33467        : (w->phys_cursor.hpos < row->used[TEXT_AREA])))
 33468     {
 33469       bool on_p = w->phys_cursor_on_p;
 33470       int x1;
 33471       int hpos = w->phys_cursor.hpos;
 33472 
 33473       /* When the window is hscrolled, cursor hpos can legitimately be
 33474          out of bounds, but we draw the cursor at the corresponding
 33475          window margin in that case.  */
 33476       if (!row->reversed_p && hpos < 0)
 33477         hpos = 0;
 33478       if (row->reversed_p && hpos >= row->used[TEXT_AREA])
 33479         hpos = row->used[TEXT_AREA] - 1;
 33480 
 33481       x1 = draw_glyphs (w, w->phys_cursor.x, row, TEXT_AREA, hpos, hpos + 1,
 33482                         hl, 0);
 33483       w->phys_cursor_on_p = on_p;
 33484 
 33485       if (hl == DRAW_CURSOR)
 33486         w->phys_cursor_width = x1 - w->phys_cursor.x;
 33487       /* When we erase the cursor, and ROW is overlapped by other
 33488          rows, make sure that these overlapping parts of other rows
 33489          are redrawn.  */
 33490       else if (hl == DRAW_NORMAL_TEXT && row->overlapped_p)
 33491         {
 33492           w->phys_cursor_width = x1 - w->phys_cursor.x;
 33493 
 33494           if (row > w->current_matrix->rows
 33495               && MATRIX_ROW_OVERLAPS_SUCC_P (row - 1))
 33496             gui_fix_overlapping_area (w, row - 1, TEXT_AREA,
 33497                                     OVERLAPS_ERASED_CURSOR);
 33498 
 33499           if (MATRIX_ROW_BOTTOM_Y (row) < window_text_bottom_y (w)
 33500               && MATRIX_ROW_OVERLAPS_PRED_P (row + 1))
 33501             gui_fix_overlapping_area (w, row + 1, TEXT_AREA,
 33502                                     OVERLAPS_ERASED_CURSOR);
 33503         }
 33504     }
 33505 }
 33506 
 33507 
 33508 /* Erase the image of a cursor of window W from the screen.  */
 33509 
 33510 void
 33511 erase_phys_cursor (struct window *w)
 33512 {
 33513   struct frame *f = XFRAME (w->frame);
 33514   Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (f);
 33515   int hpos = w->phys_cursor.hpos;
 33516   int vpos = w->phys_cursor.vpos;
 33517   bool mouse_face_here_p = false;
 33518   struct glyph_matrix *active_glyphs = w->current_matrix;
 33519   struct glyph_row *cursor_row;
 33520   struct glyph *cursor_glyph;
 33521   enum draw_glyphs_face hl;
 33522 
 33523   /* No cursor displayed or row invalidated => nothing to do on the
 33524      screen.  */
 33525   if (w->phys_cursor_type == NO_CURSOR)
 33526     goto mark_cursor_off;
 33527 
 33528   /* VPOS >= active_glyphs->nrows means that window has been resized.
 33529      Don't bother to erase the cursor.  */
 33530   if (vpos >= active_glyphs->nrows)
 33531     goto mark_cursor_off;
 33532 
 33533   /* If row containing cursor is marked invalid, there is nothing we
 33534      can do.  */
 33535   cursor_row = MATRIX_ROW (active_glyphs, vpos);
 33536   if (!cursor_row->enabled_p)
 33537     goto mark_cursor_off;
 33538 
 33539   /* If line spacing is > 0, old cursor may only be partially visible in
 33540      window after split-window.  So adjust visible height.  */
 33541   cursor_row->visible_height = min (cursor_row->visible_height,
 33542                                     window_text_bottom_y (w) - cursor_row->y);
 33543 
 33544   /* If row is completely invisible, don't attempt to delete a cursor which
 33545      isn't there.  This can happen if cursor is at top of a window, and
 33546      we switch to a buffer with a header line in that window.  */
 33547   if (cursor_row->visible_height <= 0)
 33548     goto mark_cursor_off;
 33549 
 33550   /* If cursor is in the fringe, erase by drawing actual bitmap there.  */
 33551   if (cursor_row->cursor_in_fringe_p)
 33552     {
 33553       cursor_row->cursor_in_fringe_p = false;
 33554       draw_fringe_bitmap (w, cursor_row, cursor_row->reversed_p);
 33555       goto mark_cursor_off;
 33556     }
 33557 
 33558   /* This can happen when the new row is shorter than the old one.
 33559      In this case, either draw_glyphs or clear_end_of_line
 33560      should have cleared the cursor.  Note that we wouldn't be
 33561      able to erase the cursor in this case because we don't have a
 33562      cursor glyph at hand.  */
 33563   if ((cursor_row->reversed_p
 33564        ? (w->phys_cursor.hpos < 0)
 33565        : (w->phys_cursor.hpos >= cursor_row->used[TEXT_AREA])))
 33566     goto mark_cursor_off;
 33567 
 33568   /* When the window is hscrolled, cursor hpos can legitimately be out
 33569      of bounds, but we draw the cursor at the corresponding window
 33570      margin in that case.  */
 33571   if (!cursor_row->reversed_p && hpos < 0)
 33572     hpos = 0;
 33573   if (cursor_row->reversed_p && hpos >= cursor_row->used[TEXT_AREA])
 33574     hpos = cursor_row->used[TEXT_AREA] - 1;
 33575 
 33576   /* If the cursor is in the mouse face area, redisplay that when
 33577      we clear the cursor.  */
 33578   if (! NILP (hlinfo->mouse_face_window)
 33579       && coords_in_mouse_face_p (w, hpos, vpos)
 33580       /* Don't redraw the cursor's spot in mouse face if it is at the
 33581          end of a line (on a newline).  The cursor appears there, but
 33582          mouse highlighting does not.  */
 33583       && cursor_row->used[TEXT_AREA] > hpos && hpos >= 0)
 33584     mouse_face_here_p = true;
 33585 
 33586 #ifdef HAVE_WINDOW_SYSTEM
 33587   /* Since erasing the phys cursor will probably lead to corruption of
 33588      the mouse face display if the glyph's pixel_width is not kept up
 33589      to date with the :box property of the mouse face, just redraw the
 33590      mouse face.  */
 33591   if (FRAME_WINDOW_P (WINDOW_XFRAME (w)) && mouse_face_here_p)
 33592     {
 33593       w->phys_cursor_on_p = false;
 33594       w->phys_cursor_type = NO_CURSOR;
 33595       show_mouse_face (MOUSE_HL_INFO (WINDOW_XFRAME (w)), DRAW_MOUSE_FACE);
 33596       return;
 33597     }
 33598 #endif
 33599 
 33600   /* Maybe clear the display under the cursor.  */
 33601   if (w->phys_cursor_type == HOLLOW_BOX_CURSOR)
 33602     {
 33603       int x, y;
 33604       int tab_line_height = WINDOW_TAB_LINE_HEIGHT (w);
 33605       int header_line_height = WINDOW_HEADER_LINE_HEIGHT (w);
 33606       int width;
 33607 
 33608       cursor_glyph = get_phys_cursor_glyph (w);
 33609       if (cursor_glyph == NULL)
 33610         goto mark_cursor_off;
 33611 
 33612       width = cursor_glyph->pixel_width;
 33613       x = w->phys_cursor.x;
 33614       if (x < 0)
 33615         {
 33616           width += x;
 33617           x = 0;
 33618         }
 33619       width = min (width, window_box_width (w, TEXT_AREA) - x);
 33620       y = WINDOW_TO_FRAME_PIXEL_Y (w, max (tab_line_height, max (header_line_height, cursor_row->y)));
 33621       x = WINDOW_TEXT_TO_FRAME_PIXEL_X (w, x);
 33622 
 33623       if (width > 0)
 33624         FRAME_RIF (f)->clear_frame_area (f, x, y, width, cursor_row->visible_height);
 33625     }
 33626 
 33627   /* Erase the cursor by redrawing the character underneath it.  */
 33628   if (mouse_face_here_p)
 33629     hl = DRAW_MOUSE_FACE;
 33630   else
 33631     hl = DRAW_NORMAL_TEXT;
 33632   draw_phys_cursor_glyph (w, cursor_row, hl);
 33633 
 33634  mark_cursor_off:
 33635   w->phys_cursor_on_p = false;
 33636   w->phys_cursor_type = NO_CURSOR;
 33637 }
 33638 
 33639 
 33640 /* Display or clear cursor of window W.  If !ON, clear the cursor.
 33641    If ON, display the cursor; where to put the cursor is specified by
 33642    HPOS, VPOS, X and Y.  */
 33643 
 33644 void
 33645 display_and_set_cursor (struct window *w, bool on,
 33646                         int hpos, int vpos, int x, int y)
 33647 {
 33648   struct frame *f = XFRAME (w->frame);
 33649   int new_cursor_type;
 33650   int new_cursor_width UNINIT;
 33651   bool active_cursor;
 33652   struct glyph_row *glyph_row;
 33653   struct glyph *glyph;
 33654 
 33655   /* This is pointless on invisible frames, and dangerous on garbaged
 33656      windows and frames; in the latter case, the frame or window may
 33657      be in the midst of changing its size, and x and y may be off the
 33658      window.  */
 33659   if (! FRAME_REDISPLAY_P (f)
 33660       || vpos >= w->current_matrix->nrows
 33661       || hpos >= w->current_matrix->matrix_w)
 33662     return;
 33663 
 33664   /* If cursor is off and we want it off, return quickly.  */
 33665   if (!on && !w->phys_cursor_on_p)
 33666     return;
 33667 
 33668   glyph_row = MATRIX_ROW (w->current_matrix, vpos);
 33669   /* If cursor row is not enabled, we don't really know where to
 33670      display the cursor.  */
 33671   if (!glyph_row->enabled_p)
 33672     {
 33673       w->phys_cursor_on_p = false;
 33674       return;
 33675     }
 33676 
 33677   /* A frame might be marked garbaged even though its cursor position
 33678      is correct, and will not change upon subsequent redisplay.  This
 33679      happens in some rare situations, like toggling the sort order in
 33680      Dired windows.  We've already established that VPOS is valid, so
 33681      it shouldn't do any harm to record the cursor position, as we are
 33682      going to return without acting on it anyway.  Otherwise, expose
 33683      events might come in and call update_window_cursor, which will
 33684      blindly use outdated values in w->phys_cursor.  */
 33685   if (FRAME_GARBAGED_P (f))
 33686     {
 33687       if (on)
 33688         {
 33689           w->phys_cursor.x = x;
 33690           w->phys_cursor.y = glyph_row->y;
 33691           w->phys_cursor.hpos = hpos;
 33692           w->phys_cursor.vpos = vpos;
 33693         }
 33694       return;
 33695     }
 33696 
 33697   glyph = NULL;
 33698   if (0 <= hpos && hpos < glyph_row->used[TEXT_AREA])
 33699     glyph = glyph_row->glyphs[TEXT_AREA] + hpos;
 33700 
 33701   eassert (input_blocked_p ());
 33702 
 33703   /* Set new_cursor_type to the cursor we want to be displayed.  */
 33704   new_cursor_type = get_window_cursor_type (w, glyph,
 33705                                             &new_cursor_width, &active_cursor);
 33706 
 33707   /* If cursor is currently being shown and we don't want it to be or
 33708      it is in the wrong place, or the cursor type is not what we want,
 33709      erase it.  */
 33710   if (w->phys_cursor_on_p
 33711       && (!on
 33712           || w->phys_cursor.x != x
 33713           || w->phys_cursor.y != y
 33714           /* HPOS can be negative in R2L rows whose
 33715              exact_window_width_line_p flag is set (i.e. their newline
 33716              would "overflow into the fringe").  */
 33717           || hpos < 0
 33718           || new_cursor_type != w->phys_cursor_type
 33719           || ((new_cursor_type == BAR_CURSOR || new_cursor_type == HBAR_CURSOR)
 33720               && new_cursor_width != w->phys_cursor_width)))
 33721     erase_phys_cursor (w);
 33722 
 33723   /* Don't check phys_cursor_on_p here because that flag is only set
 33724      to false in some cases where we know that the cursor has been
 33725      completely erased, to avoid the extra work of erasing the cursor
 33726      twice.  In other words, phys_cursor_on_p can be true and the cursor
 33727      still not be visible, or it has only been partly erased.  */
 33728   if (on)
 33729     {
 33730       w->phys_cursor_ascent = glyph_row->ascent;
 33731       w->phys_cursor_height = glyph_row->height;
 33732 
 33733       /* Set phys_cursor_.* before x_draw_.* is called because some
 33734          of them may need the information.  */
 33735       w->phys_cursor.x = x;
 33736       w->phys_cursor.y = glyph_row->y;
 33737       w->phys_cursor.hpos = hpos;
 33738       w->phys_cursor.vpos = vpos;
 33739     }
 33740 
 33741   FRAME_RIF (f)->draw_window_cursor (w, glyph_row, x, y,
 33742                                      new_cursor_type, new_cursor_width,
 33743                                      on, active_cursor);
 33744 }
 33745 
 33746 
 33747 /* Switch the display of W's cursor on or off, according to the value
 33748    of ON.  */
 33749 
 33750 static void
 33751 update_window_cursor (struct window *w, bool on)
 33752 {
 33753   /* Don't update cursor in windows whose frame is in the process
 33754      of being deleted.  */
 33755   if (w->current_matrix)
 33756     {
 33757       int hpos = w->phys_cursor.hpos;
 33758       int vpos = w->phys_cursor.vpos;
 33759       struct glyph_row *row;
 33760 
 33761       if (vpos >= w->current_matrix->nrows
 33762           || hpos >= w->current_matrix->matrix_w)
 33763         return;
 33764 
 33765       row = MATRIX_ROW (w->current_matrix, vpos);
 33766 
 33767       /* When the window is hscrolled, cursor hpos can legitimately be
 33768          out of bounds, but we draw the cursor at the corresponding
 33769          window margin in that case.  */
 33770       if (!row->reversed_p && hpos < 0)
 33771         hpos = 0;
 33772       if (row->reversed_p && hpos >= row->used[TEXT_AREA])
 33773         hpos = row->used[TEXT_AREA] - 1;
 33774 
 33775       block_input ();
 33776       display_and_set_cursor (w, on, hpos, vpos,
 33777                               w->phys_cursor.x, w->phys_cursor.y);
 33778       unblock_input ();
 33779     }
 33780 }
 33781 
 33782 
 33783 /* Call update_window_cursor with parameter ON_P on all leaf windows
 33784    in the window tree rooted at W.  */
 33785 
 33786 static void
 33787 update_cursor_in_window_tree (struct window *w, bool on_p)
 33788 {
 33789   while (w)
 33790     {
 33791       if (WINDOWP (w->contents))
 33792         update_cursor_in_window_tree (XWINDOW (w->contents), on_p);
 33793       else
 33794         update_window_cursor (w, on_p);
 33795 
 33796       w = NILP (w->next) ? 0 : XWINDOW (w->next);
 33797     }
 33798 }
 33799 
 33800 
 33801 /* EXPORT:
 33802    Display the cursor on window W, or clear it, according to ON_P.
 33803    Don't change the cursor's position.  */
 33804 
 33805 void
 33806 gui_update_cursor (struct frame *f, bool on_p)
 33807 {
 33808   update_cursor_in_window_tree (XWINDOW (f->root_window), on_p);
 33809 }
 33810 
 33811 
 33812 /* EXPORT:
 33813    Clear the cursor of window W to background color, and mark the
 33814    cursor as not shown.  This is used when the text where the cursor
 33815    is about to be rewritten.  */
 33816 
 33817 void
 33818 gui_clear_cursor (struct window *w)
 33819 {
 33820   if (FRAME_REDISPLAY_P (XFRAME (w->frame)) && w->phys_cursor_on_p)
 33821     update_window_cursor (w, false);
 33822 }
 33823 
 33824 #endif /* HAVE_WINDOW_SYSTEM */
 33825 
 33826 /* Implementation of draw_row_with_mouse_face for GUI sessions, GPM,
 33827    and MSDOS.  */
 33828 static void
 33829 draw_row_with_mouse_face (struct window *w, int start_x, struct glyph_row *row,
 33830                           int start_hpos, int end_hpos,
 33831                           enum draw_glyphs_face draw)
 33832 {
 33833 #ifdef HAVE_WINDOW_SYSTEM
 33834   if (FRAME_WINDOW_P (XFRAME (w->frame)))
 33835     {
 33836       draw_glyphs (w, start_x, row, TEXT_AREA, start_hpos, end_hpos, draw, 0);
 33837       return;
 33838     }
 33839 #endif
 33840 
 33841 #ifndef HAVE_ANDROID
 33842   tty_draw_row_with_mouse_face (w, row, start_hpos, end_hpos, draw);
 33843 #endif
 33844 }
 33845 
 33846 /* Display the active region described by mouse_face_* according to DRAW.  */
 33847 
 33848 static void
 33849 show_mouse_face (Mouse_HLInfo *hlinfo, enum draw_glyphs_face draw)
 33850 {
 33851   /* Don't bother doing anything if the mouse-face window is not set
 33852      up.  */
 33853   if (!WINDOWP (hlinfo->mouse_face_window))
 33854     return;
 33855 
 33856   struct window *w = XWINDOW (hlinfo->mouse_face_window);
 33857   struct frame *f = XFRAME (WINDOW_FRAME (w));
 33858 
 33859   /* Don't bother doing anything if we are on a wrong frame.  */
 33860   if (f != hlinfo->mouse_face_mouse_frame)
 33861     return;
 33862 
 33863   if (/* If window is in the process of being destroyed, don't bother
 33864          to do anything.  */
 33865       w->current_matrix != NULL
 33866       /* Don't update mouse highlight if hidden.  */
 33867       && (draw != DRAW_MOUSE_FACE || !hlinfo->mouse_face_hidden)
 33868       /* Recognize when we are called to operate on rows that don't exist
 33869          anymore.  This can happen when a window is split.  */
 33870       && hlinfo->mouse_face_end_row < w->current_matrix->nrows)
 33871     {
 33872       bool phys_cursor_on_p = w->phys_cursor_on_p;
 33873 #ifdef HAVE_WINDOW_SYSTEM
 33874       int mouse_off = 0;
 33875 #endif
 33876       struct glyph_row *row, *first, *last;
 33877 
 33878       first = MATRIX_ROW (w->current_matrix, hlinfo->mouse_face_beg_row);
 33879       last = MATRIX_ROW (w->current_matrix, hlinfo->mouse_face_end_row);
 33880 
 33881       for (row = first; row <= last && row->enabled_p; ++row)
 33882         {
 33883           int start_hpos, end_hpos, start_x;
 33884 
 33885           /* For all but the first row, the highlight starts at column 0.  */
 33886           if (row == first)
 33887             {
 33888               /* R2L rows have BEG and END in reversed order, but the
 33889                  screen drawing geometry is always left to right.  So
 33890                  we need to mirror the beginning and end of the
 33891                  highlighted area in R2L rows.  */
 33892               if (!row->reversed_p)
 33893                 {
 33894                   start_hpos = hlinfo->mouse_face_beg_col;
 33895                   start_x = hlinfo->mouse_face_beg_x;
 33896                 }
 33897               else if (row == last)
 33898                 {
 33899                   start_hpos = hlinfo->mouse_face_end_col;
 33900                   start_x = hlinfo->mouse_face_end_x;
 33901                 }
 33902               else
 33903                 {
 33904                   start_hpos = 0;
 33905                   start_x = 0;
 33906                 }
 33907             }
 33908           else if (row->reversed_p && row == last)
 33909             {
 33910               start_hpos = hlinfo->mouse_face_end_col;
 33911               start_x = hlinfo->mouse_face_end_x;
 33912             }
 33913           else
 33914             {
 33915               start_hpos = 0;
 33916               start_x = 0;
 33917             }
 33918 
 33919           if (row == last)
 33920             {
 33921               if (!row->reversed_p)
 33922                 end_hpos = hlinfo->mouse_face_end_col;
 33923               else if (row == first)
 33924                 end_hpos = hlinfo->mouse_face_beg_col;
 33925               else
 33926                 {
 33927                   end_hpos = row->used[TEXT_AREA];
 33928                   if (draw == DRAW_NORMAL_TEXT)
 33929                     row->fill_line_p = true; /* Clear to end of line.  */
 33930                 }
 33931             }
 33932           else if (row->reversed_p && row == first)
 33933             end_hpos = hlinfo->mouse_face_beg_col;
 33934           else
 33935             {
 33936               end_hpos = row->used[TEXT_AREA];
 33937               if (draw == DRAW_NORMAL_TEXT)
 33938                 row->fill_line_p = true; /* Clear to end of line.  */
 33939             }
 33940 
 33941           if (end_hpos > start_hpos)
 33942             {
 33943               draw_row_with_mouse_face (w, start_x, row,
 33944                                         start_hpos, end_hpos, draw);
 33945 
 33946               row->mouse_face_p
 33947                 = draw == DRAW_MOUSE_FACE || draw == DRAW_IMAGE_RAISED;
 33948             }
 33949 #ifdef HAVE_WINDOW_SYSTEM
 33950           /* Compute the cursor offset due to mouse-highlight.  */
 33951           if ((MATRIX_ROW_VPOS (row, w->current_matrix) == w->phys_cursor.vpos)
 33952               /* But not when highlighting a pseudo window, such as
 33953                  the toolbar, which can't have a cursor anyway.  */
 33954               && !w->pseudo_window_p
 33955               && draw == DRAW_MOUSE_FACE)
 33956             get_cursor_offset_for_mouse_face (w, row, &mouse_off);
 33957 #endif
 33958         }
 33959 
 33960       /* When we've written over the cursor, arrange for it to
 33961          be displayed again.  */
 33962       if (FRAME_WINDOW_P (f)
 33963           && phys_cursor_on_p && !w->phys_cursor_on_p)
 33964         {
 33965 #ifdef HAVE_WINDOW_SYSTEM
 33966           int hpos = w->phys_cursor.hpos;
 33967           int old_phys_cursor_x = w->phys_cursor.x;
 33968 
 33969           /* When the window is hscrolled, cursor hpos can legitimately be
 33970              out of bounds, but we draw the cursor at the corresponding
 33971              window margin in that case.  */
 33972           if (!row->reversed_p && hpos < 0)
 33973             hpos = 0;
 33974           if (row->reversed_p && hpos >= row->used[TEXT_AREA])
 33975             hpos = row->used[TEXT_AREA] - 1;
 33976 
 33977           block_input ();
 33978           display_and_set_cursor (w, true, hpos, w->phys_cursor.vpos,
 33979                                   w->phys_cursor.x + mouse_off,
 33980                                   w->phys_cursor.y);
 33981           /* Restore the original cursor coordinates, perhaps modified
 33982              to account for mouse-highlight.  */
 33983           w->phys_cursor.x = old_phys_cursor_x;
 33984           unblock_input ();
 33985 #endif  /* HAVE_WINDOW_SYSTEM */
 33986         }
 33987     }
 33988 
 33989 #ifdef HAVE_WINDOW_SYSTEM
 33990   /* Change the mouse cursor.  */
 33991   if (FRAME_WINDOW_P (f) && NILP (track_mouse))
 33992     {
 33993       if (draw == DRAW_NORMAL_TEXT
 33994 #ifndef HAVE_EXT_TOOL_BAR
 33995           && !EQ (hlinfo->mouse_face_window, f->tool_bar_window)
 33996 #endif
 33997           && !EQ (hlinfo->mouse_face_window, f->tab_bar_window))
 33998         FRAME_RIF (f)->define_frame_cursor (f, FRAME_OUTPUT_DATA (f)->text_cursor);
 33999       else
 34000       if (draw == DRAW_MOUSE_FACE)
 34001         FRAME_RIF (f)->define_frame_cursor (f, FRAME_OUTPUT_DATA (f)->hand_cursor);
 34002       else
 34003         FRAME_RIF (f)->define_frame_cursor (f, FRAME_OUTPUT_DATA (f)->nontext_cursor);
 34004     }
 34005 #endif  /* HAVE_WINDOW_SYSTEM */
 34006 }
 34007 
 34008 /* EXPORT:
 34009    Clear out the mouse-highlighted active region.
 34010    Redraw it un-highlighted first.  Value is true if mouse
 34011    face was actually drawn unhighlighted.  */
 34012 
 34013 bool
 34014 clear_mouse_face (Mouse_HLInfo *hlinfo)
 34015 {
 34016   bool cleared
 34017     = !hlinfo->mouse_face_hidden && !NILP (hlinfo->mouse_face_window);
 34018   if (cleared)
 34019     show_mouse_face (hlinfo, DRAW_NORMAL_TEXT);
 34020   hlinfo->mouse_face_beg_row = hlinfo->mouse_face_beg_col = -1;
 34021   hlinfo->mouse_face_end_row = hlinfo->mouse_face_end_col = -1;
 34022   hlinfo->mouse_face_window = Qnil;
 34023   hlinfo->mouse_face_overlay = Qnil;
 34024   return cleared;
 34025 }
 34026 
 34027 /* Return true if the coordinates HPOS and VPOS on windows W are
 34028    within the mouse face on that window.  */
 34029 static bool
 34030 coords_in_mouse_face_p (struct window *w, int hpos, int vpos)
 34031 {
 34032   Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (XFRAME (w->frame));
 34033 
 34034   /* Quickly resolve the easy cases.  */
 34035   if (!(WINDOWP (hlinfo->mouse_face_window)
 34036         && XWINDOW (hlinfo->mouse_face_window) == w))
 34037     return false;
 34038   if (vpos < hlinfo->mouse_face_beg_row
 34039       || vpos > hlinfo->mouse_face_end_row)
 34040     return false;
 34041   if (vpos > hlinfo->mouse_face_beg_row
 34042       && vpos < hlinfo->mouse_face_end_row)
 34043     return true;
 34044 
 34045   if (!MATRIX_ROW (w->current_matrix, vpos)->reversed_p)
 34046     {
 34047       if (hlinfo->mouse_face_beg_row == hlinfo->mouse_face_end_row)
 34048         {
 34049           if (hlinfo->mouse_face_beg_col <= hpos && hpos < hlinfo->mouse_face_end_col)
 34050             return true;
 34051         }
 34052       else if ((vpos == hlinfo->mouse_face_beg_row
 34053                 && hpos >= hlinfo->mouse_face_beg_col)
 34054                || (vpos == hlinfo->mouse_face_end_row
 34055                    && hpos < hlinfo->mouse_face_end_col))
 34056         return true;
 34057     }
 34058   else
 34059     {
 34060        if (hlinfo->mouse_face_beg_row == hlinfo->mouse_face_end_row)
 34061         {
 34062           if (hlinfo->mouse_face_end_col < hpos && hpos <= hlinfo->mouse_face_beg_col)
 34063             return true;
 34064         }
 34065       else if ((vpos == hlinfo->mouse_face_beg_row
 34066                 && hpos <= hlinfo->mouse_face_beg_col)
 34067                || (vpos == hlinfo->mouse_face_end_row
 34068                    && hpos > hlinfo->mouse_face_end_col))
 34069         return true;
 34070     }
 34071   return false;
 34072 }
 34073 
 34074 
 34075 /* EXPORT:
 34076    True if physical cursor of window W is within mouse face.  */
 34077 
 34078 bool
 34079 cursor_in_mouse_face_p (struct window *w)
 34080 {
 34081   int vpos = w->phys_cursor.vpos;
 34082 
 34083   /* If the cursor is outside the matrix glyph rows, it cannot be
 34084      within the mouse face.  */
 34085   if (!(0 <= vpos && vpos < w->current_matrix->nrows))
 34086     return false;
 34087 
 34088   int hpos = w->phys_cursor.hpos;
 34089   struct glyph_row *row = MATRIX_ROW (w->current_matrix, vpos);
 34090 
 34091   /* When the window is hscrolled, cursor hpos can legitimately be out
 34092      of bounds, but we draw the cursor at the corresponding window
 34093      margin in that case.  */
 34094   if (!row->reversed_p && hpos < 0)
 34095     hpos = 0;
 34096   if (row->reversed_p && hpos >= row->used[TEXT_AREA])
 34097     hpos = row->used[TEXT_AREA] - 1;
 34098 
 34099   return coords_in_mouse_face_p (w, hpos, vpos);
 34100 }
 34101 
 34102 
 34103 
 34104 /* Find the glyph rows START_ROW and END_ROW of window W that display
 34105    characters between buffer positions START_CHARPOS and END_CHARPOS
 34106    (excluding END_CHARPOS).  DISP_STRING is a display string that
 34107    covers these buffer positions.  This is similar to
 34108    row_containing_pos, but is more accurate when bidi reordering makes
 34109    buffer positions change non-linearly with glyph rows.  */
 34110 static void
 34111 rows_from_pos_range (struct window *w,
 34112                      ptrdiff_t start_charpos, ptrdiff_t end_charpos,
 34113                      Lisp_Object disp_string,
 34114                      struct glyph_row **start, struct glyph_row **end)
 34115 {
 34116   struct glyph_row *first = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
 34117   int last_y = window_text_bottom_y (w);
 34118   struct glyph_row *row;
 34119 
 34120   *start = NULL;
 34121   *end = NULL;
 34122 
 34123   while (!first->enabled_p
 34124          && first < MATRIX_BOTTOM_TEXT_ROW (w->current_matrix, w))
 34125     first++;
 34126 
 34127   /* Find the START row.  */
 34128   for (row = first;
 34129        row->enabled_p && MATRIX_ROW_BOTTOM_Y (row) <= last_y;
 34130        row++)
 34131     {
 34132       /* A row can potentially be the START row if the range of the
 34133          characters it displays intersects the range
 34134          [START_CHARPOS..END_CHARPOS).  */
 34135       if (! ((start_charpos < MATRIX_ROW_START_CHARPOS (row)
 34136               && end_charpos < MATRIX_ROW_START_CHARPOS (row))
 34137              /* See the commentary in row_containing_pos, for the
 34138                 explanation of the complicated way to check whether
 34139                 some position is beyond the end of the characters
 34140                 displayed by a row.  */
 34141              || ((start_charpos > MATRIX_ROW_END_CHARPOS (row)
 34142                   || (start_charpos == MATRIX_ROW_END_CHARPOS (row)
 34143                       && !row->ends_at_zv_p
 34144                       && !MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (row)))
 34145                  && (end_charpos > MATRIX_ROW_END_CHARPOS (row)
 34146                      || (end_charpos == MATRIX_ROW_END_CHARPOS (row)
 34147                          && !row->ends_at_zv_p
 34148                          && !MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (row))))))
 34149         {
 34150           /* Found a candidate row.  Now make sure at least one of the
 34151              glyphs it displays has a charpos from the range
 34152              [START_CHARPOS..END_CHARPOS).
 34153 
 34154              This is not obvious because bidi reordering could make
 34155              buffer positions of a row be 1,2,3,102,101,100, and if we
 34156              want to highlight characters in [50..60), we don't want
 34157              this row, even though [50..60) does intersect [1..103),
 34158              the range of character positions given by the row's start
 34159              and end positions.  */
 34160           struct glyph *g = row->glyphs[TEXT_AREA];
 34161           struct glyph *e = g + row->used[TEXT_AREA];
 34162 
 34163           while (g < e)
 34164             {
 34165               if (((BUFFERP (g->object) || NILP (g->object))
 34166                    && start_charpos <= g->charpos && g->charpos < end_charpos)
 34167                   /* A glyph that comes from DISP_STRING is by
 34168                      definition to be highlighted.  */
 34169                   || EQ (g->object, disp_string))
 34170                 *start = row;
 34171               g++;
 34172             }
 34173           if (*start)
 34174             break;
 34175         }
 34176     }
 34177 
 34178   /* Find the END row.  */
 34179   if (!*start
 34180       /* If the last row is partially visible, start looking for END
 34181          from that row, instead of starting from FIRST.  */
 34182       && !(row->enabled_p
 34183            && row->y < last_y && MATRIX_ROW_BOTTOM_Y (row) > last_y))
 34184     row = first;
 34185   for ( ; row->enabled_p && MATRIX_ROW_BOTTOM_Y (row) <= last_y; row++)
 34186     {
 34187       struct glyph_row *next = row + 1;
 34188       ptrdiff_t next_start = MATRIX_ROW_START_CHARPOS (next);
 34189 
 34190       if (!next->enabled_p
 34191           || next >= MATRIX_BOTTOM_TEXT_ROW (w->current_matrix, w)
 34192           /* The first row >= START whose range of displayed characters
 34193              does NOT intersect the range [START_CHARPOS..END_CHARPOS]
 34194              is the row END + 1.  */
 34195           || (start_charpos < next_start
 34196               && end_charpos < next_start)
 34197           || ((start_charpos > MATRIX_ROW_END_CHARPOS (next)
 34198                || (start_charpos == MATRIX_ROW_END_CHARPOS (next)
 34199                    && !next->ends_at_zv_p
 34200                    && !MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (next)))
 34201               && (end_charpos > MATRIX_ROW_END_CHARPOS (next)
 34202                   || (end_charpos == MATRIX_ROW_END_CHARPOS (next)
 34203                       && !next->ends_at_zv_p
 34204                       && !MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (next)))))
 34205         {
 34206           *end = row;
 34207           break;
 34208         }
 34209       else
 34210         {
 34211           /* If the next row's edges intersect [START_CHARPOS..END_CHARPOS],
 34212              but none of the characters it displays are in the range, it is
 34213              also END + 1. */
 34214           struct glyph *g = next->glyphs[TEXT_AREA];
 34215           struct glyph *s = g;
 34216           struct glyph *e = g + next->used[TEXT_AREA];
 34217 
 34218           while (g < e)
 34219             {
 34220               if (((BUFFERP (g->object) || NILP (g->object))
 34221                    && ((start_charpos <= g->charpos && g->charpos < end_charpos)
 34222                        /* If the buffer position of the first glyph in
 34223                           the row is equal to END_CHARPOS, it means
 34224                           the last character to be highlighted is the
 34225                           newline of ROW, and we must consider NEXT as
 34226                           END, not END+1.  */
 34227                        || (((!next->reversed_p && g == s)
 34228                             || (next->reversed_p && g == e - 1))
 34229                            && (g->charpos == end_charpos
 34230                                /* Special case for when NEXT is an
 34231                                   empty line at ZV.  */
 34232                                || (g->charpos == -1
 34233                                    && !row->ends_at_zv_p
 34234                                    && next_start == end_charpos)))))
 34235                   /* A glyph that comes from DISP_STRING is by
 34236                      definition to be highlighted.  */
 34237                   || EQ (g->object, disp_string))
 34238                 break;
 34239               g++;
 34240             }
 34241           if (g == e)
 34242             {
 34243               *end = row;
 34244               break;
 34245             }
 34246           /* The first row that ends at ZV must be the last to be
 34247              highlighted.  */
 34248           else if (next->ends_at_zv_p)
 34249             {
 34250               *end = next;
 34251               break;
 34252             }
 34253         }
 34254     }
 34255 }
 34256 
 34257 /* This function sets the mouse_face_* elements of HLINFO, assuming
 34258    the mouse cursor is on a glyph with buffer charpos MOUSE_CHARPOS in
 34259    window WINDOW.  START_CHARPOS and END_CHARPOS are buffer positions
 34260    for the overlay or run of text properties specifying the mouse
 34261    face.  BEFORE_STRING and AFTER_STRING, if non-nil, are a
 34262    before-string and after-string that must also be highlighted.
 34263    DISP_STRING, if non-nil, is a display string that may cover some
 34264    or all of the highlighted text.  */
 34265 
 34266 static void
 34267 mouse_face_from_buffer_pos (Lisp_Object window,
 34268                             Mouse_HLInfo *hlinfo,
 34269                             ptrdiff_t mouse_charpos,
 34270                             ptrdiff_t start_charpos,
 34271                             ptrdiff_t end_charpos,
 34272                             Lisp_Object before_string,
 34273                             Lisp_Object after_string,
 34274                             Lisp_Object disp_string)
 34275 {
 34276   struct window *w = XWINDOW (window);
 34277   struct glyph_row *first = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
 34278   struct glyph_row *r1, *r2;
 34279   struct glyph *glyph, *end;
 34280   ptrdiff_t ignore, pos;
 34281   int x;
 34282 
 34283   eassert (NILP (disp_string) || STRINGP (disp_string));
 34284   eassert (NILP (before_string) || STRINGP (before_string));
 34285   eassert (NILP (after_string) || STRINGP (after_string));
 34286 
 34287   /* Find the rows corresponding to START_CHARPOS and END_CHARPOS.  */
 34288   rows_from_pos_range (w, start_charpos, end_charpos, disp_string, &r1, &r2);
 34289   if (r1 == NULL)
 34290     r1 = MATRIX_ROW (w->current_matrix, w->window_end_vpos);
 34291   /* If the before-string or display-string contains newlines,
 34292      rows_from_pos_range skips to its last row.  Move back.  */
 34293   if (!NILP (before_string) || !NILP (disp_string))
 34294     {
 34295       struct glyph_row *prev;
 34296       while ((prev = r1 - 1, prev >= first)
 34297              && MATRIX_ROW_END_CHARPOS (prev) == start_charpos
 34298              && prev->used[TEXT_AREA] > 0)
 34299         {
 34300           struct glyph *beg = prev->glyphs[TEXT_AREA];
 34301           glyph = beg + prev->used[TEXT_AREA];
 34302           while (--glyph >= beg && NILP (glyph->object));
 34303           if (glyph < beg
 34304               || !(EQ (glyph->object, before_string)
 34305                    || EQ (glyph->object, disp_string)))
 34306             break;
 34307           r1 = prev;
 34308         }
 34309     }
 34310   if (r2 == NULL)
 34311     {
 34312       r2 = MATRIX_ROW (w->current_matrix, w->window_end_vpos);
 34313       hlinfo->mouse_face_past_end = true;
 34314     }
 34315   else if (!NILP (after_string))
 34316     {
 34317       /* If the after-string has newlines, advance to its last row.  */
 34318       struct glyph_row *next;
 34319       struct glyph_row *last
 34320         = MATRIX_ROW (w->current_matrix, w->window_end_vpos);
 34321 
 34322       for (next = r2 + 1;
 34323            next <= last
 34324              && next->used[TEXT_AREA] > 0
 34325              && EQ (next->glyphs[TEXT_AREA]->object, after_string);
 34326            ++next)
 34327         r2 = next;
 34328     }
 34329   /* The rest of the display engine assumes that mouse_face_beg_row is
 34330      either above mouse_face_end_row or identical to it.  But with
 34331      bidi-reordered continued lines, the row for START_CHARPOS could
 34332      be below the row for END_CHARPOS.  If so, swap the rows and store
 34333      them in correct order.  */
 34334   if (r1->y > r2->y)
 34335     {
 34336       struct glyph_row *tem = r2;
 34337 
 34338       r2 = r1;
 34339       r1 = tem;
 34340     }
 34341 
 34342   hlinfo->mouse_face_beg_row = MATRIX_ROW_VPOS (r1, w->current_matrix);
 34343   hlinfo->mouse_face_end_row = MATRIX_ROW_VPOS (r2, w->current_matrix);
 34344 
 34345   /* For a bidi-reordered row, the positions of BEFORE_STRING,
 34346      AFTER_STRING, DISP_STRING, START_CHARPOS, and END_CHARPOS
 34347      could be anywhere in the row and in any order.  The strategy
 34348      below is to find the leftmost and the rightmost glyph that
 34349      belongs to either of these 3 strings, or whose position is
 34350      between START_CHARPOS and END_CHARPOS, and highlight all the
 34351      glyphs between those two.  This may cover more than just the text
 34352      between START_CHARPOS and END_CHARPOS if the range of characters
 34353      strides the bidi level boundary, e.g. if the beginning is in R2L
 34354      text while the end is in L2R text or vice versa.  */
 34355   if (!r1->reversed_p)
 34356     {
 34357       /* This row is in a left to right paragraph.  Scan it left to
 34358          right.  */
 34359       glyph = r1->glyphs[TEXT_AREA];
 34360       end = glyph + r1->used[TEXT_AREA];
 34361       x = r1->x;
 34362 
 34363       /* Skip truncation glyphs at the start of the glyph row.  */
 34364       if (MATRIX_ROW_DISPLAYS_TEXT_P (r1))
 34365         for (; glyph < end
 34366                && NILP (glyph->object)
 34367                && glyph->charpos < 0;
 34368              ++glyph)
 34369           x += glyph->pixel_width;
 34370 
 34371       /* Scan the glyph row, looking for BEFORE_STRING, AFTER_STRING,
 34372          or DISP_STRING, and the first glyph from buffer whose
 34373          position is between START_CHARPOS and END_CHARPOS.  */
 34374       for (; glyph < end
 34375              && !NILP (glyph->object)
 34376              && !EQ (glyph->object, disp_string)
 34377              && !(BUFFERP (glyph->object)
 34378                   && (glyph->charpos >= start_charpos
 34379                       && glyph->charpos < end_charpos));
 34380            ++glyph)
 34381         {
 34382           /* BEFORE_STRING or AFTER_STRING are only relevant if they
 34383              are present at buffer positions between START_CHARPOS and
 34384              END_CHARPOS, or if they come from an overlay.  */
 34385           if (EQ (glyph->object, before_string))
 34386             {
 34387               pos = string_buffer_position (before_string,
 34388                                             start_charpos);
 34389               /* If pos == 0, it means before_string came from an
 34390                  overlay, not from a buffer position.  */
 34391               if (!pos || (pos >= start_charpos && pos < end_charpos))
 34392                 break;
 34393             }
 34394           else if (EQ (glyph->object, after_string))
 34395             {
 34396               pos = string_buffer_position (after_string, end_charpos);
 34397               if (!pos || (pos >= start_charpos && pos < end_charpos))
 34398                 break;
 34399             }
 34400           x += glyph->pixel_width;
 34401         }
 34402       hlinfo->mouse_face_beg_x = x;
 34403       hlinfo->mouse_face_beg_col = glyph - r1->glyphs[TEXT_AREA];
 34404     }
 34405   else
 34406     {
 34407       /* This row is in a right to left paragraph.  Scan it right to
 34408          left.  */
 34409       struct glyph *g;
 34410 
 34411       end = r1->glyphs[TEXT_AREA] - 1;
 34412       glyph = end + r1->used[TEXT_AREA];
 34413 
 34414       /* Skip truncation glyphs at the start of the glyph row.  */
 34415       if (MATRIX_ROW_DISPLAYS_TEXT_P (r1))
 34416         for (; glyph > end
 34417                && NILP (glyph->object)
 34418                && glyph->charpos < 0;
 34419              --glyph)
 34420           ;
 34421 
 34422       /* Scan the glyph row, looking for BEFORE_STRING, AFTER_STRING,
 34423          or DISP_STRING, and the first glyph from buffer whose
 34424          position is between START_CHARPOS and END_CHARPOS.  */
 34425       for (; glyph > end
 34426              && !NILP (glyph->object)
 34427              && !EQ (glyph->object, disp_string)
 34428              && !(BUFFERP (glyph->object)
 34429                   && (glyph->charpos >= start_charpos
 34430                       && glyph->charpos < end_charpos));
 34431            --glyph)
 34432         {
 34433           /* BEFORE_STRING or AFTER_STRING are only relevant if they
 34434              are present at buffer positions between START_CHARPOS and
 34435              END_CHARPOS, or if they come from an overlay.  */
 34436           if (EQ (glyph->object, before_string))
 34437             {
 34438               pos = string_buffer_position (before_string, start_charpos);
 34439               /* If pos == 0, it means before_string came from an
 34440                  overlay, not from a buffer position.  */
 34441               if (!pos || (pos >= start_charpos && pos < end_charpos))
 34442                 break;
 34443             }
 34444           else if (EQ (glyph->object, after_string))
 34445             {
 34446               pos = string_buffer_position (after_string, end_charpos);
 34447               if (!pos || (pos >= start_charpos && pos < end_charpos))
 34448                 break;
 34449             }
 34450         }
 34451 
 34452       glyph++; /* first glyph to the right of the highlighted area */
 34453       for (g = r1->glyphs[TEXT_AREA], x = r1->x; g < glyph; g++)
 34454         x += g->pixel_width;
 34455       hlinfo->mouse_face_beg_x = x;
 34456       hlinfo->mouse_face_beg_col = glyph - r1->glyphs[TEXT_AREA];
 34457     }
 34458 
 34459   /* If the highlight ends in a different row, compute GLYPH and END
 34460      for the end row.  Otherwise, reuse the values computed above for
 34461      the row where the highlight begins.  */
 34462   if (r2 != r1)
 34463     {
 34464       if (!r2->reversed_p)
 34465         {
 34466           glyph = r2->glyphs[TEXT_AREA];
 34467           end = glyph + r2->used[TEXT_AREA];
 34468           x = r2->x;
 34469         }
 34470       else
 34471         {
 34472           end = r2->glyphs[TEXT_AREA] - 1;
 34473           glyph = end + r2->used[TEXT_AREA];
 34474         }
 34475     }
 34476 
 34477   if (!r2->reversed_p)
 34478     {
 34479       /* Skip truncation and continuation glyphs near the end of the
 34480          row, and also blanks and stretch glyphs inserted by
 34481          extend_face_to_end_of_line.  */
 34482       while (end > glyph
 34483              && NILP ((end - 1)->object))
 34484         --end;
 34485       /* Scan the rest of the glyph row from the end, looking for the
 34486          first glyph that comes from BEFORE_STRING, AFTER_STRING, or
 34487          DISP_STRING, or whose position is between START_CHARPOS
 34488          and END_CHARPOS */
 34489       for (--end;
 34490              end > glyph
 34491              && !NILP (end->object)
 34492              && !EQ (end->object, disp_string)
 34493              && !(BUFFERP (end->object)
 34494                   && (end->charpos >= start_charpos
 34495                       && end->charpos < end_charpos));
 34496            --end)
 34497         {
 34498           /* BEFORE_STRING or AFTER_STRING are only relevant if they
 34499              are present at buffer positions between START_CHARPOS and
 34500              END_CHARPOS, or if they come from an overlay.  */
 34501           if (EQ (end->object, before_string))
 34502             {
 34503               pos = string_buffer_position (before_string, start_charpos);
 34504               if (!pos || (pos >= start_charpos && pos < end_charpos))
 34505                 break;
 34506             }
 34507           else if (EQ (end->object, after_string))
 34508             {
 34509               pos = string_buffer_position (after_string, end_charpos);
 34510               if (!pos || (pos >= start_charpos && pos < end_charpos))
 34511                 break;
 34512             }
 34513         }
 34514       /* Find the X coordinate of the last glyph to be highlighted.  */
 34515       for (; glyph <= end; ++glyph)
 34516         x += glyph->pixel_width;
 34517 
 34518       hlinfo->mouse_face_end_x = x;
 34519       hlinfo->mouse_face_end_col = glyph - r2->glyphs[TEXT_AREA];
 34520     }
 34521   else
 34522     {
 34523       /* Skip truncation and continuation glyphs near the end of the
 34524          row, and also blanks and stretch glyphs inserted by
 34525          extend_face_to_end_of_line.  */
 34526       x = r2->x;
 34527       end++;
 34528       while (end < glyph
 34529              && NILP (end->object))
 34530         {
 34531           x += end->pixel_width;
 34532           ++end;
 34533         }
 34534       /* Scan the rest of the glyph row from the end, looking for the
 34535          first glyph that comes from BEFORE_STRING, AFTER_STRING, or
 34536          DISP_STRING, or whose position is between START_CHARPOS
 34537          and END_CHARPOS */
 34538       for ( ;
 34539              end < glyph
 34540              && !NILP (end->object)
 34541              && !EQ (end->object, disp_string)
 34542              && !(BUFFERP (end->object)
 34543                   && (end->charpos >= start_charpos
 34544                       && end->charpos < end_charpos));
 34545            ++end)
 34546         {
 34547           /* BEFORE_STRING or AFTER_STRING are only relevant if they
 34548              are present at buffer positions between START_CHARPOS and
 34549              END_CHARPOS, or if they come from an overlay.  */
 34550           if (EQ (end->object, before_string))
 34551             {
 34552               pos = string_buffer_position (before_string, start_charpos);
 34553               if (!pos || (pos >= start_charpos && pos < end_charpos))
 34554                 break;
 34555             }
 34556           else if (EQ (end->object, after_string))
 34557             {
 34558               pos = string_buffer_position (after_string, end_charpos);
 34559               if (!pos || (pos >= start_charpos && pos < end_charpos))
 34560                 break;
 34561             }
 34562           x += end->pixel_width;
 34563         }
 34564       /* If we exited the above loop because we arrived at the last
 34565          glyph of the row, and its buffer position is still not in
 34566          range, it means the last character in range is the preceding
 34567          newline.  Bump the end column and x values to get past the
 34568          last glyph.  */
 34569       if (end == glyph
 34570           && BUFFERP (end->object)
 34571           && (end->charpos < start_charpos
 34572               || end->charpos >= end_charpos))
 34573         {
 34574           x += end->pixel_width;
 34575           ++end;
 34576         }
 34577       hlinfo->mouse_face_end_x = x;
 34578       hlinfo->mouse_face_end_col = end - r2->glyphs[TEXT_AREA];
 34579     }
 34580 
 34581   hlinfo->mouse_face_window = window;
 34582   hlinfo->mouse_face_face_id
 34583     = face_at_buffer_position (w, mouse_charpos, &ignore,
 34584                                mouse_charpos + 1,
 34585                                !hlinfo->mouse_face_hidden, -1, 0);
 34586   show_mouse_face (hlinfo, DRAW_MOUSE_FACE);
 34587 }
 34588 
 34589 /* The following function is not used anymore (replaced with
 34590    mouse_face_from_string_pos), but I leave it here for the time
 34591    being, in case someone would.  */
 34592 
 34593 #if false       /* not used */
 34594 
 34595 /* Find the position of the glyph for position POS in OBJECT in
 34596    window W's current matrix, and return in *X, *Y the pixel
 34597    coordinates, and return in *HPOS, *VPOS the column/row of the glyph.
 34598 
 34599    RIGHT_P means return the position of the right edge of the glyph.
 34600    !RIGHT_P means return the left edge position.
 34601 
 34602    If no glyph for POS exists in the matrix, return the position of
 34603    the glyph with the next smaller position that is in the matrix, if
 34604    RIGHT_P is false.  If RIGHT_P, and no glyph for POS
 34605    exists in the matrix, return the position of the glyph with the
 34606    next larger position in OBJECT.
 34607 
 34608    Value is true if a glyph was found.  */
 34609 
 34610 static bool
 34611 fast_find_string_pos (struct window *w, ptrdiff_t pos, Lisp_Object object,
 34612                       int *hpos, int *vpos, int *x, int *y, bool right_p)
 34613 {
 34614   int yb = window_text_bottom_y (w);
 34615   struct glyph_row *r;
 34616   struct glyph *best_glyph = NULL;
 34617   struct glyph_row *best_row = NULL;
 34618   int best_x = 0;
 34619 
 34620   for (r = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
 34621        r->enabled_p && r->y < yb;
 34622        ++r)
 34623     {
 34624       struct glyph *g = r->glyphs[TEXT_AREA];
 34625       struct glyph *e = g + r->used[TEXT_AREA];
 34626       int gx;
 34627 
 34628       for (gx = r->x; g < e; gx += g->pixel_width, ++g)
 34629         if (EQ (g->object, object))
 34630           {
 34631             if (g->charpos == pos)
 34632               {
 34633                 best_glyph = g;
 34634                 best_x = gx;
 34635                 best_row = r;
 34636                 goto found;
 34637               }
 34638             else if (best_glyph == NULL
 34639                      || ((eabs (g->charpos - pos)
 34640                          < eabs (best_glyph->charpos - pos))
 34641                          && (right_p
 34642                              ? g->charpos < pos
 34643                              : g->charpos > pos)))
 34644               {
 34645                 best_glyph = g;
 34646                 best_x = gx;
 34647                 best_row = r;
 34648               }
 34649           }
 34650     }
 34651 
 34652  found:
 34653 
 34654   if (best_glyph)
 34655     {
 34656       *x = best_x;
 34657       *hpos = best_glyph - best_row->glyphs[TEXT_AREA];
 34658 
 34659       if (right_p)
 34660         {
 34661           *x += best_glyph->pixel_width;
 34662           ++*hpos;
 34663         }
 34664 
 34665       *y = best_row->y;
 34666       *vpos = MATRIX_ROW_VPOS (best_row, w->current_matrix);
 34667     }
 34668 
 34669   return best_glyph != NULL;
 34670 }
 34671 #endif  /* not used */
 34672 
 34673 /* Find the positions of the first and the last glyphs in window W's
 34674    current matrix that occlude positions [STARTPOS..ENDPOS) in OBJECT
 34675    (assumed to be a string), and return in HLINFO's mouse_face_*
 34676    members the pixel and column/row coordinates of those glyphs.  */
 34677 
 34678 static void
 34679 mouse_face_from_string_pos (struct window *w, Mouse_HLInfo *hlinfo,
 34680                             Lisp_Object object,
 34681                             ptrdiff_t startpos, ptrdiff_t endpos)
 34682 {
 34683   int yb = window_text_bottom_y (w);
 34684   struct glyph_row *r;
 34685   struct glyph *g, *e;
 34686   int gx;
 34687   bool found = false;
 34688 
 34689   /* Find the glyph row with at least one position in the range
 34690      [STARTPOS..ENDPOS), and the first glyph in that row whose
 34691      position belongs to that range.  */
 34692   for (r = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
 34693        r->enabled_p && r->y < yb;
 34694        ++r)
 34695     {
 34696       if (!r->reversed_p)
 34697         {
 34698           g = r->glyphs[TEXT_AREA];
 34699           e = g + r->used[TEXT_AREA];
 34700           for (gx = r->x; g < e; gx += g->pixel_width, ++g)
 34701             if (EQ (g->object, object)
 34702                 && startpos <= g->charpos && g->charpos < endpos)
 34703               {
 34704                 hlinfo->mouse_face_beg_row
 34705                   = MATRIX_ROW_VPOS (r, w->current_matrix);
 34706                 hlinfo->mouse_face_beg_col = g - r->glyphs[TEXT_AREA];
 34707                 hlinfo->mouse_face_beg_x = gx;
 34708                 found = true;
 34709                 break;
 34710               }
 34711         }
 34712       else
 34713         {
 34714           struct glyph *g1;
 34715 
 34716           e = r->glyphs[TEXT_AREA];
 34717           g = e + r->used[TEXT_AREA];
 34718           for ( ; g > e; --g)
 34719             if (EQ ((g-1)->object, object)
 34720                 && startpos <= (g-1)->charpos && (g-1)->charpos < endpos)
 34721               {
 34722                 hlinfo->mouse_face_beg_row
 34723                   = MATRIX_ROW_VPOS (r, w->current_matrix);
 34724                 hlinfo->mouse_face_beg_col = g - r->glyphs[TEXT_AREA];
 34725                 for (gx = r->x, g1 = r->glyphs[TEXT_AREA]; g1 < g; ++g1)
 34726                   gx += g1->pixel_width;
 34727                 hlinfo->mouse_face_beg_x = gx;
 34728                 found = true;
 34729                 break;
 34730               }
 34731         }
 34732       if (found)
 34733         break;
 34734     }
 34735 
 34736   if (!found)
 34737     return;
 34738 
 34739   /* Starting with the next row, look for the first row which does NOT
 34740      include any glyphs whose positions are in the range.  */
 34741   for (++r; r->enabled_p && r->y < yb; ++r)
 34742     {
 34743       g = r->glyphs[TEXT_AREA];
 34744       e = g + r->used[TEXT_AREA];
 34745       found = false;
 34746       for ( ; g < e; ++g)
 34747         if (EQ (g->object, object)
 34748             && startpos <= g->charpos && g->charpos < endpos)
 34749           {
 34750             found = true;
 34751             break;
 34752           }
 34753       if (!found)
 34754         break;
 34755     }
 34756 
 34757   /* The highlighted region ends on the previous row.  */
 34758   r--;
 34759 
 34760   /* Set the end row.  */
 34761   hlinfo->mouse_face_end_row = MATRIX_ROW_VPOS (r, w->current_matrix);
 34762 
 34763   /* Compute and set the end column and the end column's horizontal
 34764      pixel coordinate.  */
 34765   if (!r->reversed_p)
 34766     {
 34767       g = r->glyphs[TEXT_AREA];
 34768       e = g + r->used[TEXT_AREA];
 34769       for ( ; e > g; --e)
 34770         if (EQ ((e-1)->object, object)
 34771             && startpos <= (e-1)->charpos && (e-1)->charpos < endpos)
 34772           break;
 34773       hlinfo->mouse_face_end_col = e - g;
 34774 
 34775       for (gx = r->x; g < e; ++g)
 34776         gx += g->pixel_width;
 34777       hlinfo->mouse_face_end_x = gx;
 34778     }
 34779   else
 34780     {
 34781       e = r->glyphs[TEXT_AREA];
 34782       g = e + r->used[TEXT_AREA];
 34783       for (gx = r->x ; e < g; ++e)
 34784         {
 34785           if (EQ (e->object, object)
 34786               && startpos <= e->charpos && e->charpos < endpos)
 34787             break;
 34788           gx += e->pixel_width;
 34789         }
 34790       hlinfo->mouse_face_end_col = e - r->glyphs[TEXT_AREA];
 34791       hlinfo->mouse_face_end_x = gx;
 34792     }
 34793 }
 34794 
 34795 #ifdef HAVE_WINDOW_SYSTEM
 34796 
 34797 /* See if position X, Y is within a hot-spot of an image.  */
 34798 
 34799 static bool
 34800 on_hot_spot_p (Lisp_Object hot_spot, int x, int y)
 34801 {
 34802   if (!CONSP (hot_spot))
 34803     return false;
 34804 
 34805   if (EQ (XCAR (hot_spot), Qrect))
 34806     {
 34807       /* CDR is (Top-Left . Bottom-Right) = ((x0 . y0) . (x1 . y1))  */
 34808       Lisp_Object rect = XCDR (hot_spot);
 34809       Lisp_Object tem;
 34810       if (!CONSP (rect))
 34811         return false;
 34812       if (!CONSP (XCAR (rect)))
 34813         return false;
 34814       if (!CONSP (XCDR (rect)))
 34815         return false;
 34816       if (!(tem = XCAR (XCAR (rect)), FIXNUMP (tem) && x >= XFIXNUM (tem)))
 34817         return false;
 34818       if (!(tem = XCDR (XCAR (rect)), FIXNUMP (tem) && y >= XFIXNUM (tem)))
 34819         return false;
 34820       if (!(tem = XCAR (XCDR (rect)), FIXNUMP (tem) && x <= XFIXNUM (tem)))
 34821         return false;
 34822       if (!(tem = XCDR (XCDR (rect)), FIXNUMP (tem) && y <= XFIXNUM (tem)))
 34823         return false;
 34824       return true;
 34825     }
 34826   else if (EQ (XCAR (hot_spot), Qcircle))
 34827     {
 34828       /* CDR is (Center . Radius) = ((x0 . y0) . r) */
 34829       Lisp_Object circ = XCDR (hot_spot);
 34830       Lisp_Object lr, lx0, ly0;
 34831       if (CONSP (circ)
 34832           && CONSP (XCAR (circ))
 34833           && (lr = XCDR (circ), NUMBERP (lr))
 34834           && (lx0 = XCAR (XCAR (circ)), FIXNUMP (lx0))
 34835           && (ly0 = XCDR (XCAR (circ)), FIXNUMP (ly0)))
 34836         {
 34837           double r = XFLOATINT (lr);
 34838           double dx = XFIXNUM (lx0) - x;
 34839           double dy = XFIXNUM (ly0) - y;
 34840           return (dx * dx + dy * dy <= r * r);
 34841         }
 34842     }
 34843   else if (EQ (XCAR (hot_spot), Qpoly))
 34844     {
 34845       /* CDR is [x0 y0 x1 y1 x2 y2 ...x(n-1) y(n-1)] */
 34846       if (VECTORP (XCDR (hot_spot)))
 34847         {
 34848           struct Lisp_Vector *v = XVECTOR (XCDR (hot_spot));
 34849           Lisp_Object *poly = v->contents;
 34850           ptrdiff_t n = v->header.size;
 34851           ptrdiff_t i;
 34852           bool inside = false;
 34853           Lisp_Object lx, ly;
 34854           int x0, y0;
 34855 
 34856           /* Need an even number of coordinates, and at least 3 edges.  */
 34857           if (n < 6 || n & 1)
 34858             return false;
 34859 
 34860           /* Count edge segments intersecting line from (X,Y) to (X,infinity).
 34861              If count is odd, we are inside polygon.  Pixels on edges
 34862              may or may not be included depending on actual geometry of the
 34863              polygon.  */
 34864           if ((lx = poly[n-2], !FIXNUMP (lx))
 34865               || (ly = poly[n-1], !FIXNUMP (lx)))
 34866             return false;
 34867           x0 = XFIXNUM (lx), y0 = XFIXNUM (ly);
 34868           for (i = 0; i < n; i += 2)
 34869             {
 34870               int x1 = x0, y1 = y0;
 34871               if ((lx = poly[i], !FIXNUMP (lx))
 34872                   || (ly = poly[i+1], !FIXNUMP (ly)))
 34873                 return false;
 34874               x0 = XFIXNUM (lx), y0 = XFIXNUM (ly);
 34875 
 34876               /* Does this segment cross the X line?  */
 34877               if (x0 >= x)
 34878                 {
 34879                   if (x1 >= x)
 34880                     continue;
 34881                 }
 34882               else if (x1 < x)
 34883                 continue;
 34884               if (y > y0 && y > y1)
 34885                 continue;
 34886               if (y < y0 + ((y1 - y0) * (x - x0)) / (x1 - x0))
 34887                 inside = !inside;
 34888             }
 34889           return inside;
 34890         }
 34891     }
 34892   return false;
 34893 }
 34894 
 34895 Lisp_Object
 34896 find_hot_spot (Lisp_Object map, int x, int y)
 34897 {
 34898   while (CONSP (map))
 34899     {
 34900       if (CONSP (XCAR (map))
 34901           && on_hot_spot_p (XCAR (XCAR (map)), x, y))
 34902         return XCAR (map);
 34903       map = XCDR (map);
 34904     }
 34905 
 34906   return Qnil;
 34907 }
 34908 
 34909 DEFUN ("lookup-image-map", Flookup_image_map, Slookup_image_map,
 34910        3, 3, 0,
 34911        doc: /* Lookup in image map MAP coordinates X and Y.
 34912 An image map is an alist where each element has the format (AREA ID PLIST).
 34913 An AREA is specified as either a rectangle, a circle, or a polygon:
 34914 A rectangle is a cons (rect . ((x0 . y0) . (x1 . y1))) specifying the
 34915 pixel coordinates of the upper left and bottom right corners.
 34916 A circle is a cons (circle . ((x0 . y0) . r)) specifying the center
 34917 and the radius of the circle; r may be a float or integer.
 34918 A polygon is a cons (poly . [x0 y0 x1 y1 ...]) where each pair in the
 34919 vector describes one corner in the polygon.
 34920 Returns the alist element for the first matching AREA in MAP.  */)
 34921   (Lisp_Object map, Lisp_Object x, Lisp_Object y)
 34922 {
 34923   if (NILP (map))
 34924     return Qnil;
 34925 
 34926   CHECK_FIXNUM (x);
 34927   CHECK_FIXNUM (y);
 34928 
 34929   return find_hot_spot (map,
 34930                         clip_to_bounds (INT_MIN, XFIXNUM (x), INT_MAX),
 34931                         clip_to_bounds (INT_MIN, XFIXNUM (y), INT_MAX));
 34932 }
 34933 #endif  /* HAVE_WINDOW_SYSTEM */
 34934 
 34935 
 34936 /* Display frame CURSOR, optionally using shape defined by POINTER.  */
 34937 static void
 34938 define_frame_cursor1 (struct frame *f, Emacs_Cursor cursor, Lisp_Object pointer)
 34939 {
 34940 #ifdef HAVE_WINDOW_SYSTEM
 34941   if (!FRAME_WINDOW_P (f))
 34942     return;
 34943 
 34944   /* Do not change cursor shape while dragging mouse.  */
 34945   if (EQ (track_mouse, Qdragging) || EQ (track_mouse, Qdropping)
 34946       || EQ (track_mouse, Qdrag_source))
 34947     return;
 34948 
 34949   if (!NILP (pointer))
 34950     {
 34951       if (EQ (pointer, Qarrow))
 34952         cursor = FRAME_OUTPUT_DATA (f)->nontext_cursor;
 34953       else if (EQ (pointer, Qhand))
 34954         cursor = FRAME_OUTPUT_DATA (f)->hand_cursor;
 34955       else if (EQ (pointer, Qtext))
 34956         cursor = FRAME_OUTPUT_DATA (f)->text_cursor;
 34957       else if (EQ (pointer, intern ("hdrag")))
 34958         cursor = FRAME_OUTPUT_DATA (f)->horizontal_drag_cursor;
 34959       else if (EQ (pointer, intern ("nhdrag")))
 34960         cursor = FRAME_OUTPUT_DATA (f)->vertical_drag_cursor;
 34961 # ifdef HAVE_X_WINDOWS
 34962       else if (EQ (pointer, intern ("vdrag")))
 34963         cursor = FRAME_DISPLAY_INFO (f)->vertical_scroll_bar_cursor;
 34964 # endif
 34965       else if (EQ (pointer, intern ("hourglass")))
 34966         cursor = FRAME_OUTPUT_DATA (f)->hourglass_cursor;
 34967       else if (EQ (pointer, Qmodeline))
 34968         cursor = FRAME_OUTPUT_DATA (f)->modeline_cursor;
 34969       else
 34970         cursor = FRAME_OUTPUT_DATA (f)->nontext_cursor;
 34971     }
 34972 
 34973   if (cursor != No_Cursor)
 34974     FRAME_RIF (f)->define_frame_cursor (f, cursor);
 34975 #endif
 34976 }
 34977 
 34978 /* Take proper action when mouse has moved to the mode or header line
 34979    or marginal area AREA of window W, x-position X and y-position Y.
 34980    X is relative to the start of the text display area of W, so the
 34981    width of bitmap areas and scroll bars must be subtracted to get a
 34982    position relative to the start of the mode line.  */
 34983 
 34984 static void
 34985 note_mode_line_or_margin_highlight (Lisp_Object window, int x, int y,
 34986                                     enum window_part area)
 34987 {
 34988   struct window *w = XWINDOW (window);
 34989   struct frame *f = XFRAME (w->frame);
 34990   Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (f);
 34991   Emacs_Cursor cursor = No_Cursor;
 34992   Lisp_Object pointer = Qnil;
 34993   int dx, dy, width, height;
 34994   ptrdiff_t charpos;
 34995   Lisp_Object string, object = Qnil;
 34996   Lisp_Object pos UNINIT;
 34997   Lisp_Object mouse_face;
 34998   int original_x_pixel = x;
 34999   struct glyph * glyph = NULL, * row_start_glyph = NULL;
 35000   struct glyph_row *row UNINIT;
 35001 
 35002   if (area == ON_MODE_LINE || area == ON_HEADER_LINE || area == ON_TAB_LINE)
 35003     {
 35004       int x0;
 35005       struct glyph *end;
 35006 
 35007       /* Kludge alert: mode_line_string takes X/Y in pixels, but
 35008          returns them in row/column units!  */
 35009       string = mode_line_string (w, area, &x, &y, &charpos,
 35010                                  &object, &dx, &dy, &width, &height);
 35011 
 35012       row = (area == ON_MODE_LINE
 35013              ? MATRIX_MODE_LINE_ROW (w->current_matrix)
 35014              : (area == ON_TAB_LINE
 35015                 ? MATRIX_TAB_LINE_ROW (w->current_matrix)
 35016                 : MATRIX_HEADER_LINE_ROW (w->current_matrix)));
 35017 
 35018       /* Find the glyph under the mouse pointer.  */
 35019       if (row->mode_line_p && row->enabled_p)
 35020         {
 35021           glyph = row_start_glyph = row->glyphs[TEXT_AREA];
 35022           end = glyph + row->used[TEXT_AREA];
 35023 
 35024           for (x0 = original_x_pixel;
 35025                glyph < end && x0 >= glyph->pixel_width;
 35026                ++glyph)
 35027             x0 -= glyph->pixel_width;
 35028 
 35029           if (glyph >= end)
 35030             glyph = NULL;
 35031         }
 35032     }
 35033   else
 35034     {
 35035       x -= WINDOW_LEFT_SCROLL_BAR_AREA_WIDTH (w);
 35036       /* Kludge alert: marginal_area_string takes X/Y in pixels, but
 35037          returns them in row/column units!  */
 35038       string = marginal_area_string (w, area, &x, &y, &charpos,
 35039                                      &object, &dx, &dy, &width, &height);
 35040     }
 35041 
 35042   Lisp_Object help = Qnil;
 35043 
 35044 #ifdef HAVE_WINDOW_SYSTEM
 35045   if (IMAGEP (object))
 35046     {
 35047       Lisp_Object image_map, hotspot;
 35048       if ((image_map = plist_get (XCDR (object), QCmap),
 35049            !NILP (image_map))
 35050           && (hotspot = find_hot_spot (image_map, dx, dy),
 35051               CONSP (hotspot))
 35052           && (hotspot = XCDR (hotspot), CONSP (hotspot)))
 35053         {
 35054           Lisp_Object plist;
 35055 
 35056           /* Could check XCAR (hotspot) to see if we enter/leave this hot-spot.
 35057              If so, we could look for mouse-enter, mouse-leave
 35058              properties in PLIST (and do something...).  */
 35059           hotspot = XCDR (hotspot);
 35060           if (CONSP (hotspot)
 35061               && (plist = XCAR (hotspot), CONSP (plist)))
 35062             {
 35063               pointer = plist_get (plist, Qpointer);
 35064               if (NILP (pointer))
 35065                 pointer = Qhand;
 35066               help = plist_get (plist, Qhelp_echo);
 35067               if (!NILP (help))
 35068                 {
 35069                   help_echo_string = help;
 35070                   XSETWINDOW (help_echo_window, w);
 35071                   help_echo_object = w->contents;
 35072                   help_echo_pos = charpos;
 35073                 }
 35074             }
 35075         }
 35076       if (NILP (pointer))
 35077         pointer = plist_get (XCDR (object), QCpointer);
 35078     }
 35079 #endif  /* HAVE_WINDOW_SYSTEM */
 35080 
 35081   /* CHARPOS can be beyond the last position of STRING due, e.g., to
 35082      min-width 'display' property.  Fix that, to let all the calls to
 35083      get-text-property below do their thing.  */
 35084   if (STRINGP (string))
 35085     pos = make_fixnum (min (charpos, SCHARS (string) - 1));
 35086 
 35087   /* Set the help text and mouse pointer.  If the mouse is on a part
 35088      of the mode line without any text (e.g. past the right edge of
 35089      the mode line text), use that windows's mode line help echo if it
 35090      has been set.  */
 35091   if (STRINGP (string) || area == ON_MODE_LINE || area == ON_HEADER_LINE
 35092       || area == ON_TAB_LINE)
 35093     {
 35094       /* Arrange to display the help by setting the global variables
 35095          help_echo_string, help_echo_object, and help_echo_pos.  */
 35096       if (NILP (help))
 35097         {
 35098           if (STRINGP (string))
 35099             help = Fget_text_property (pos, Qhelp_echo, string);
 35100 
 35101           if (!NILP (help))
 35102             {
 35103               help_echo_string = help;
 35104               XSETWINDOW (help_echo_window, w);
 35105               help_echo_object = string;
 35106               help_echo_pos = charpos;
 35107             }
 35108           else if (area == ON_MODE_LINE
 35109                    && !NILP (w->mode_line_help_echo))
 35110             {
 35111               help_echo_string =  w->mode_line_help_echo;
 35112               XSETWINDOW (help_echo_window, w);
 35113               help_echo_object = Qnil;
 35114               help_echo_pos = -1;
 35115             }
 35116         }
 35117 
 35118 #ifdef HAVE_WINDOW_SYSTEM
 35119       /* Change the mouse pointer according to what is under it.  */
 35120       if (FRAME_WINDOW_P (f))
 35121         {
 35122           bool draggable = (! WINDOW_BOTTOMMOST_P (w)
 35123                             || minibuf_level
 35124                             || NILP (Vresize_mini_windows));
 35125 
 35126           if (STRINGP (string))
 35127             {
 35128               cursor = FRAME_OUTPUT_DATA (f)->nontext_cursor;
 35129 
 35130               if (NILP (pointer))
 35131                 pointer = Fget_text_property (pos, Qpointer, string);
 35132 
 35133               /* Change the mouse pointer according to what is under X/Y.  */
 35134               if (NILP (pointer)
 35135                   && (area == ON_MODE_LINE || area == ON_HEADER_LINE
 35136                       || area == ON_TAB_LINE))
 35137                 {
 35138                   Lisp_Object map;
 35139 
 35140                   map = Fget_text_property (pos, Qlocal_map, string);
 35141                   if (!KEYMAPP (map))
 35142                     map = Fget_text_property (pos, Qkeymap, string);
 35143                   if (!KEYMAPP (map) && draggable && area == ON_MODE_LINE)
 35144                     cursor = FRAME_OUTPUT_DATA (f)->vertical_drag_cursor;
 35145                 }
 35146             }
 35147           else if (draggable && area == ON_MODE_LINE)
 35148             cursor = FRAME_OUTPUT_DATA (f)->vertical_drag_cursor;
 35149           else if ((area == ON_MODE_LINE
 35150                     && WINDOW_BOTTOMMOST_P (w)
 35151                     && !FRAME_HAS_MINIBUF_P (f)
 35152                     && !NILP (Fframe_parameter
 35153                               (w->frame, Qdrag_with_mode_line)))
 35154                    || (((area == ON_HEADER_LINE
 35155                          && !NILP (Fframe_parameter
 35156                                    (w->frame, Qdrag_with_header_line)))
 35157                         || (area == ON_TAB_LINE
 35158                             && !NILP (Fframe_parameter
 35159                                       (w->frame, Qdrag_with_tab_line))))
 35160                        && WINDOW_TOPMOST_P (w)))
 35161             cursor = FRAME_OUTPUT_DATA (f)->hand_cursor;
 35162           else
 35163             cursor = FRAME_OUTPUT_DATA (f)->nontext_cursor;
 35164         }
 35165 #endif
 35166     }
 35167 
 35168   /* Change the mouse face according to what is under X/Y.  */
 35169   bool mouse_face_shown = false;
 35170 
 35171   if (STRINGP (string))
 35172     {
 35173       mouse_face = Fget_text_property (pos, Qmouse_face, string);
 35174       if (!NILP (Vmouse_highlight) && !NILP (mouse_face)
 35175           && ((area == ON_MODE_LINE) || (area == ON_HEADER_LINE)
 35176               || (area == ON_TAB_LINE))
 35177           && glyph)
 35178         {
 35179           Lisp_Object b, e;
 35180 
 35181           struct glyph * tmp_glyph;
 35182 
 35183           int gpos;
 35184           int gseq_length;
 35185           int total_pixel_width;
 35186           ptrdiff_t begpos, endpos, ignore;
 35187 
 35188           int vpos, hpos;
 35189 
 35190           b = Fprevious_single_property_change (make_fixnum (charpos + 1),
 35191                                                 Qmouse_face, string, Qnil);
 35192           if (NILP (b))
 35193             begpos = 0;
 35194           else
 35195             begpos = XFIXNUM (b);
 35196 
 35197           e = Fnext_single_property_change (pos, Qmouse_face, string, Qnil);
 35198           if (NILP (e))
 35199             endpos = SCHARS (string);
 35200           else
 35201             endpos = XFIXNUM (e);
 35202 
 35203           /* Calculate the glyph position GPOS of GLYPH in the
 35204              displayed string, relative to the beginning of the
 35205              highlighted part of the string.
 35206 
 35207              Note: GPOS is different from CHARPOS.  CHARPOS is the
 35208              position of GLYPH in the internal string object.  A mode
 35209              line string format has structures which are converted to
 35210              a flattened string by the Emacs Lisp interpreter.  The
 35211              internal string is an element of those structures.  The
 35212              displayed string is the flattened string.  */
 35213           tmp_glyph = row_start_glyph;
 35214           while (tmp_glyph < glyph
 35215                  && (!(EQ (tmp_glyph->object, glyph->object)
 35216                        && begpos <= tmp_glyph->charpos
 35217                        && tmp_glyph->charpos < endpos)))
 35218             tmp_glyph++;
 35219           gpos = glyph - tmp_glyph;
 35220 
 35221           /* Calculate the length GSEQ_LENGTH of the glyph sequence of
 35222              the highlighted part of the displayed string to which
 35223              GLYPH belongs.  Note: GSEQ_LENGTH is different from
 35224              SCHARS (STRING), because the latter returns the length of
 35225              the internal string.  */
 35226           for (tmp_glyph = row->glyphs[TEXT_AREA] + row->used[TEXT_AREA] - 1;
 35227                tmp_glyph > glyph
 35228                  && (!(EQ (tmp_glyph->object, glyph->object)
 35229                        && begpos <= tmp_glyph->charpos
 35230                        && tmp_glyph->charpos < endpos));
 35231                tmp_glyph--)
 35232             ;
 35233           gseq_length = gpos + (tmp_glyph - glyph) + 1;
 35234 
 35235           /* Calculate the total pixel width of all the glyphs between
 35236              the beginning of the highlighted area and GLYPH.  */
 35237           total_pixel_width = 0;
 35238           for (tmp_glyph = glyph - gpos; tmp_glyph != glyph; tmp_glyph++)
 35239             total_pixel_width += tmp_glyph->pixel_width;
 35240 
 35241           /* Pre calculation of re-rendering position.  Note: X is in
 35242              column units here, after the call to mode_line_string or
 35243              marginal_area_string.  */
 35244           hpos = x - gpos;
 35245           vpos = (area == ON_MODE_LINE
 35246                   ? (w->current_matrix)->nrows - 1
 35247                   : (area == ON_TAB_LINE
 35248                      ? 0
 35249                      : (w->current_matrix->tab_line_p
 35250                         ? 1
 35251                         : 0)));
 35252 
 35253           /* If GLYPH's position is included in the region that is
 35254              already drawn in mouse face, we have nothing to do.  */
 35255           if ( EQ (window, hlinfo->mouse_face_window)
 35256                && (!row->reversed_p
 35257                    ? (hlinfo->mouse_face_beg_col <= hpos
 35258                       && hpos < hlinfo->mouse_face_end_col)
 35259                    /* In R2L rows we swap BEG and END, see below.  */
 35260                    : (hlinfo->mouse_face_end_col <= hpos
 35261                       && hpos < hlinfo->mouse_face_beg_col))
 35262                && hlinfo->mouse_face_beg_row == vpos )
 35263             return;
 35264 
 35265           if (clear_mouse_face (hlinfo))
 35266             cursor = No_Cursor;
 35267 
 35268           if (!row->reversed_p)
 35269             {
 35270               hlinfo->mouse_face_beg_col = hpos;
 35271               hlinfo->mouse_face_beg_x   = original_x_pixel
 35272                                             - (total_pixel_width + dx);
 35273               hlinfo->mouse_face_end_col = hpos + gseq_length;
 35274               hlinfo->mouse_face_end_x   = 0;
 35275             }
 35276           else
 35277             {
 35278               /* In R2L rows, show_mouse_face expects BEG and END
 35279                  coordinates to be swapped.  */
 35280               hlinfo->mouse_face_end_col = hpos;
 35281               hlinfo->mouse_face_end_x   = original_x_pixel
 35282                                             - (total_pixel_width + dx);
 35283               hlinfo->mouse_face_beg_col = hpos + gseq_length;
 35284               hlinfo->mouse_face_beg_x   = 0;
 35285             }
 35286 
 35287           hlinfo->mouse_face_beg_row  = vpos;
 35288           hlinfo->mouse_face_end_row  = hlinfo->mouse_face_beg_row;
 35289           hlinfo->mouse_face_past_end = false;
 35290           hlinfo->mouse_face_window   = window;
 35291 
 35292           hlinfo->mouse_face_face_id =
 35293             face_at_string_position (w, string, charpos, 0, &ignore,
 35294                                      glyph->face_id, true, 0);
 35295 
 35296           show_mouse_face (hlinfo, DRAW_MOUSE_FACE);
 35297           mouse_face_shown = true;
 35298 
 35299           if (NILP (pointer))
 35300             pointer = Qhand;
 35301         }
 35302     }
 35303 
 35304   /* If mouse-face doesn't need to be shown, clear any existing
 35305      mouse-face.  */
 35306   if ((area == ON_MODE_LINE || area == ON_HEADER_LINE
 35307        || area == ON_TAB_LINE) && !mouse_face_shown)
 35308     clear_mouse_face (hlinfo);
 35309 
 35310   define_frame_cursor1 (f, cursor, pointer);
 35311 }
 35312 
 35313 
 35314 /* EXPORT:
 35315    Take proper action when the mouse has moved to position X, Y on
 35316    frame F with regards to highlighting portions of display that have
 35317    mouse-face properties.  Also de-highlight portions of display where
 35318    the mouse was before, set the mouse pointer shape as appropriate
 35319    for the mouse coordinates, and activate help echo (tooltips).
 35320    X and Y can be negative or out of range.  */
 35321 
 35322 void
 35323 note_mouse_highlight (struct frame *f, int x, int y)
 35324 {
 35325   Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (f);
 35326   enum window_part part = ON_NOTHING;
 35327   Lisp_Object window;
 35328   struct window *w;
 35329   Emacs_Cursor cursor = No_Cursor;
 35330   Lisp_Object pointer = Qnil;  /* Takes precedence over cursor!  */
 35331   struct buffer *b;
 35332 
 35333   /* When a menu is active, don't highlight because this looks odd.  */
 35334 #if defined (HAVE_X_WINDOWS) || defined (HAVE_NS) || defined (MSDOS) \
 35335   || defined (HAVE_ANDROID)
 35336   if (popup_activated ())
 35337     return;
 35338 #endif
 35339 
 35340 #if defined (HAVE_HAIKU)
 35341   if (popup_activated_p)
 35342     return;
 35343 #endif
 35344 
 35345   if (!f->glyphs_initialized_p
 35346       || f->pointer_invisible)
 35347     return;
 35348 
 35349   hlinfo->mouse_face_mouse_x = x;
 35350   hlinfo->mouse_face_mouse_y = y;
 35351   hlinfo->mouse_face_mouse_frame = f;
 35352 
 35353   if (hlinfo->mouse_face_defer)
 35354     return;
 35355 
 35356   /* Which window is that in?  */
 35357   window = window_from_coordinates (f, x, y, &part, true, true);
 35358 
 35359   /* If displaying active text in another window, clear that.  */
 35360   if (! EQ (window, hlinfo->mouse_face_window)
 35361       /* Also clear if we move out of text area in same window.  */
 35362       || (!NILP (hlinfo->mouse_face_window)
 35363           && !NILP (window)
 35364           && part != ON_TEXT
 35365           && part != ON_MODE_LINE
 35366           && part != ON_HEADER_LINE
 35367           && part != ON_TAB_LINE))
 35368     clear_mouse_face (hlinfo);
 35369 
 35370   /* Reset help_echo_string.  It will get recomputed below.  */
 35371   help_echo_string = Qnil;
 35372 
 35373   /* Handle tab-bar highlight on mouse-capable TTY frames.  */
 35374   if (!FRAME_WINDOW_P (f)
 35375       && (y >= FRAME_MENU_BAR_LINES (f)
 35376           && y < FRAME_MENU_BAR_LINES (f) + FRAME_TAB_BAR_LINES (f)))
 35377     {
 35378       int prop_idx;
 35379       bool ignore;
 35380       Lisp_Object caption = tty_get_tab_bar_item (f, x, &prop_idx, &ignore);
 35381 
 35382       if (!NILP (caption))
 35383         {
 35384           help_echo_object = help_echo_window = Qnil;
 35385           help_echo_pos = -1;
 35386           help_echo_string = AREF (f->tab_bar_items,
 35387                                    prop_idx * TAB_BAR_ITEM_NSLOTS
 35388                                    + TAB_BAR_ITEM_HELP);
 35389           if (NILP (help_echo_string))
 35390             help_echo_string = caption;
 35391         }
 35392     }
 35393 
 35394 #ifdef HAVE_WINDOW_SYSTEM
 35395   /* If the cursor is on the internal border of FRAME and FRAME's
 35396      internal border is draggable, provide some visual feedback.  */
 35397   if (FRAME_INTERNAL_BORDER_WIDTH (f) > 0
 35398       && !NILP (get_frame_param (f, Qdrag_internal_border)))
 35399     {
 35400       enum internal_border_part part = frame_internal_border_part (f, x, y);
 35401 
 35402       switch (part)
 35403         {
 35404         case INTERNAL_BORDER_NONE:
 35405           if (cursor != FRAME_OUTPUT_DATA (f)->nontext_cursor)
 35406             /* Reset cursor.  */
 35407             cursor = FRAME_OUTPUT_DATA (f)->nontext_cursor;
 35408           break;
 35409         case INTERNAL_BORDER_LEFT_EDGE:
 35410           cursor = FRAME_OUTPUT_DATA (f)->left_edge_cursor;
 35411           break;
 35412         case INTERNAL_BORDER_TOP_LEFT_CORNER:
 35413           cursor = FRAME_OUTPUT_DATA (f)->top_left_corner_cursor;
 35414           break;
 35415         case INTERNAL_BORDER_TOP_EDGE:
 35416           cursor = FRAME_OUTPUT_DATA (f)->top_edge_cursor;
 35417           break;
 35418         case INTERNAL_BORDER_TOP_RIGHT_CORNER:
 35419           cursor = FRAME_OUTPUT_DATA (f)->top_right_corner_cursor;
 35420           break;
 35421         case INTERNAL_BORDER_RIGHT_EDGE:
 35422           cursor = FRAME_OUTPUT_DATA (f)->right_edge_cursor;
 35423           break;
 35424         case INTERNAL_BORDER_BOTTOM_RIGHT_CORNER:
 35425           cursor = FRAME_OUTPUT_DATA (f)->bottom_right_corner_cursor;
 35426           break;
 35427         case INTERNAL_BORDER_BOTTOM_EDGE:
 35428           cursor = FRAME_OUTPUT_DATA (f)->bottom_edge_cursor;
 35429           break;
 35430         case INTERNAL_BORDER_BOTTOM_LEFT_CORNER:
 35431           cursor = FRAME_OUTPUT_DATA (f)->bottom_left_corner_cursor;
 35432           break;
 35433         default:
 35434           /* This should not happen.  */
 35435           if (cursor != FRAME_OUTPUT_DATA (f)->nontext_cursor)
 35436             cursor = FRAME_OUTPUT_DATA (f)->nontext_cursor;
 35437         }
 35438 
 35439       if (cursor != FRAME_OUTPUT_DATA (f)->nontext_cursor)
 35440         {
 35441           /* Do we really want a help echo here?  */
 35442           help_echo_string = build_string ("drag-mouse-1: resize frame");
 35443           goto set_cursor;
 35444         }
 35445     }
 35446 #endif /* HAVE_WINDOW_SYSTEM */
 35447 
 35448   /* Not on a window -> return.  */
 35449   if (!WINDOWP (window))
 35450     return;
 35451 
 35452   /* Convert to window-relative pixel coordinates.  */
 35453   w = XWINDOW (window);
 35454   frame_to_window_pixel_xy (w, &x, &y);
 35455 
 35456 #if defined (HAVE_WINDOW_SYSTEM)
 35457   /* Handle tab-bar window differently since it doesn't display a
 35458      buffer.  */
 35459   if (EQ (window, f->tab_bar_window))
 35460     {
 35461       note_tab_bar_highlight (f, x, y);
 35462       if (tab_bar__dragging_in_progress)
 35463         {
 35464           cursor = FRAME_OUTPUT_DATA (f)->hand_cursor;
 35465           goto set_cursor;
 35466         }
 35467       else
 35468         return;
 35469     }
 35470   else
 35471     {
 35472       /* The mouse might have pressed into the tab bar, but might
 35473          also have been released outside the tab bar, so
 35474          f->last_tab_bar_item must be reset, in order to make sure the
 35475          item can be still highlighted again in the future.  */
 35476       f->last_tab_bar_item = -1;
 35477     }
 35478 #endif
 35479 
 35480 #if defined (HAVE_WINDOW_SYSTEM) && ! defined (HAVE_EXT_TOOL_BAR)
 35481   /* Handle tool-bar window differently since it doesn't display a
 35482      buffer.  */
 35483   if (EQ (window, f->tool_bar_window))
 35484     {
 35485       note_tool_bar_highlight (f, x, y);
 35486       return;
 35487     }
 35488 #endif
 35489 
 35490   /* Mouse is on the mode, header line or margin?  */
 35491   if (part == ON_MODE_LINE || part == ON_HEADER_LINE || part == ON_TAB_LINE
 35492       || part == ON_LEFT_MARGIN || part == ON_RIGHT_MARGIN)
 35493     {
 35494       note_mode_line_or_margin_highlight (window, x, y, part);
 35495 
 35496 #ifdef HAVE_WINDOW_SYSTEM
 35497       if (part == ON_LEFT_MARGIN || part == ON_RIGHT_MARGIN)
 35498         {
 35499           cursor = FRAME_OUTPUT_DATA (f)->nontext_cursor;
 35500           /* Show non-text cursor (Bug#16647).  */
 35501           goto set_cursor;
 35502         }
 35503       else
 35504 #endif
 35505         return;
 35506     }
 35507 
 35508 #ifdef HAVE_WINDOW_SYSTEM
 35509   if (part == ON_VERTICAL_BORDER)
 35510     {
 35511       cursor = FRAME_OUTPUT_DATA (f)->horizontal_drag_cursor;
 35512       help_echo_string = build_string ("drag-mouse-1: resize");
 35513       goto set_cursor;
 35514     }
 35515   else if (part == ON_RIGHT_DIVIDER)
 35516     {
 35517       cursor = FRAME_OUTPUT_DATA (f)->horizontal_drag_cursor;
 35518       help_echo_string = build_string ("drag-mouse-1: resize");
 35519       goto set_cursor;
 35520     }
 35521   else if (part == ON_BOTTOM_DIVIDER)
 35522     if (! WINDOW_BOTTOMMOST_P (w)
 35523         || minibuf_level
 35524         || NILP (Vresize_mini_windows))
 35525       {
 35526         cursor = FRAME_OUTPUT_DATA (f)->vertical_drag_cursor;
 35527         help_echo_string = build_string ("drag-mouse-1: resize");
 35528         goto set_cursor;
 35529       }
 35530     else
 35531       cursor = FRAME_OUTPUT_DATA (f)->nontext_cursor;
 35532   else if (part == ON_LEFT_FRINGE || part == ON_RIGHT_FRINGE
 35533            || part == ON_VERTICAL_SCROLL_BAR
 35534            || part == ON_HORIZONTAL_SCROLL_BAR)
 35535     cursor = FRAME_OUTPUT_DATA (f)->nontext_cursor;
 35536   else
 35537     cursor = FRAME_OUTPUT_DATA (f)->text_cursor;
 35538 #endif
 35539 
 35540   /* Are we in a window whose display is up to date?
 35541      And verify the buffer's text has not changed.  */
 35542   b = XBUFFER (w->contents);
 35543   if (part == ON_TEXT && w->window_end_valid && !window_outdated (w))
 35544     {
 35545       int hpos, vpos, dx, dy, area = LAST_AREA;
 35546       ptrdiff_t pos;
 35547       struct glyph *glyph;
 35548       Lisp_Object object;
 35549       Lisp_Object mouse_face = Qnil, position;
 35550       Lisp_Object *overlay_vec = NULL;
 35551       ptrdiff_t i, noverlays;
 35552       struct buffer *obuf;
 35553       ptrdiff_t obegv, ozv;
 35554       bool same_region;
 35555 
 35556       /* Find the glyph under X/Y.  */
 35557       glyph = x_y_to_hpos_vpos (w, x, y, &hpos, &vpos, &dx, &dy, &area);
 35558 
 35559 #ifdef HAVE_WINDOW_SYSTEM
 35560       /* Look for :pointer property on image.  */
 35561       if (glyph != NULL && glyph->type == IMAGE_GLYPH)
 35562         {
 35563           struct image *img = IMAGE_OPT_FROM_ID (f, glyph->u.img_id);
 35564           if (img != NULL && IMAGEP (img->spec))
 35565             {
 35566               Lisp_Object image_map, hotspot;
 35567               if ((image_map = plist_get (XCDR (img->spec), QCmap),
 35568                    !NILP (image_map))
 35569                   && (hotspot = find_hot_spot (image_map,
 35570                                                glyph->slice.img.x + dx,
 35571                                                glyph->slice.img.y + dy),
 35572                       CONSP (hotspot))
 35573                   && (hotspot = XCDR (hotspot), CONSP (hotspot)))
 35574                 {
 35575                   Lisp_Object plist;
 35576 
 35577                   /* Could check XCAR (hotspot) to see if we enter/leave
 35578                      this hot-spot.
 35579                      If so, we could look for mouse-enter, mouse-leave
 35580                      properties in PLIST (and do something...).  */
 35581                   hotspot = XCDR (hotspot);
 35582                   if (CONSP (hotspot)
 35583                       && (plist = XCAR (hotspot), CONSP (plist)))
 35584                     {
 35585                       pointer = plist_get (plist, Qpointer);
 35586                       if (NILP (pointer))
 35587                         pointer = Qhand;
 35588                       help_echo_string = plist_get (plist, Qhelp_echo);
 35589                       if (!NILP (help_echo_string))
 35590                         {
 35591                           help_echo_window = window;
 35592                           help_echo_object = glyph->object;
 35593                           help_echo_pos = glyph->charpos;
 35594                         }
 35595                     }
 35596                 }
 35597               if (NILP (pointer))
 35598                 pointer = plist_get (XCDR (img->spec), QCpointer);
 35599             }
 35600         }
 35601 #endif  /* HAVE_WINDOW_SYSTEM */
 35602 
 35603       /* Clear mouse face if X/Y not over text.  */
 35604       if (glyph == NULL
 35605           || area != TEXT_AREA
 35606           || !MATRIX_ROW_DISPLAYS_TEXT_P (MATRIX_ROW (w->current_matrix, vpos))
 35607           /* Glyph's OBJECT is nil for glyphs inserted by the
 35608              display engine for its internal purposes, like truncation
 35609              and continuation glyphs and blanks beyond the end of
 35610              line's text on text terminals.  If we are over such a
 35611              glyph, we are not over any text.  */
 35612           || NILP (glyph->object)
 35613           /* R2L rows have a stretch glyph at their front, which
 35614              stands for no text, whereas L2R rows have no glyphs at
 35615              all beyond the end of text.  Treat such stretch glyphs
 35616              like we do with NULL glyphs in L2R rows.  */
 35617           || (MATRIX_ROW (w->current_matrix, vpos)->reversed_p
 35618               && glyph == MATRIX_ROW_GLYPH_START (w->current_matrix, vpos)
 35619               && glyph->type == STRETCH_GLYPH
 35620               && glyph->avoid_cursor_p))
 35621         {
 35622           if (clear_mouse_face (hlinfo))
 35623             cursor = No_Cursor;
 35624           if (FRAME_WINDOW_P (f) && NILP (pointer))
 35625             {
 35626 #ifdef HAVE_WINDOW_SYSTEM
 35627               if (area != TEXT_AREA)
 35628                 cursor = FRAME_OUTPUT_DATA (f)->nontext_cursor;
 35629               else
 35630                 pointer = Vvoid_text_area_pointer;
 35631 #endif
 35632             }
 35633           goto set_cursor;
 35634         }
 35635 
 35636       pos = glyph->charpos;
 35637       object = glyph->object;
 35638       if (!STRINGP (object) && !BUFFERP (object))
 35639         goto set_cursor;
 35640 
 35641       /* If we get an out-of-range value, return now; avoid an error.  */
 35642       if (BUFFERP (object) && pos > BUF_Z (b))
 35643         goto set_cursor;
 35644 
 35645       /* Make the window's buffer temporarily current for
 35646          overlays_at and compute_char_face.  */
 35647       obuf = current_buffer;
 35648       current_buffer = b;
 35649       obegv = BEGV;
 35650       ozv = ZV;
 35651       BEGV = BEG;
 35652       ZV = Z;
 35653 
 35654       /* Is this char mouse-active or does it have help-echo?  */
 35655       position = make_fixnum (pos);
 35656 
 35657       USE_SAFE_ALLOCA;
 35658 
 35659       if (BUFFERP (object))
 35660         {
 35661           /* Put all the overlays we want in a vector in overlay_vec.  */
 35662           GET_OVERLAYS_AT (pos, overlay_vec, noverlays, NULL);
 35663           /* Sort overlays into increasing priority order.  */
 35664           noverlays = sort_overlays (overlay_vec, noverlays, w);
 35665         }
 35666       else
 35667         noverlays = 0;
 35668 
 35669       if (NILP (Vmouse_highlight))
 35670         {
 35671           clear_mouse_face (hlinfo);
 35672           goto check_help_echo;
 35673         }
 35674 
 35675       same_region = coords_in_mouse_face_p (w, hpos, vpos);
 35676 
 35677       if (same_region)
 35678         cursor = No_Cursor;
 35679 
 35680       /* Check mouse-face highlighting.  */
 35681       if (! same_region
 35682           /* If there exists an overlay with mouse-face overlapping
 35683              the one we are currently highlighting, we have to check
 35684              if we enter the overlapping overlay, and then highlight
 35685              only that.  Skip the check when mouse-face highlighting
 35686              is currently hidden to avoid Bug#30519.  */
 35687           || (!hlinfo->mouse_face_hidden
 35688               && OVERLAYP (hlinfo->mouse_face_overlay)
 35689               /* It's possible the overlay was deleted (Bug#35273).  */
 35690               && OVERLAY_BUFFER (hlinfo->mouse_face_overlay)
 35691               && mouse_face_overlay_overlaps (hlinfo->mouse_face_overlay)))
 35692         {
 35693           /* Find the highest priority overlay with a mouse-face.  */
 35694           Lisp_Object overlay = Qnil;
 35695           for (i = noverlays - 1; i >= 0 && NILP (overlay); --i)
 35696             {
 35697               mouse_face = Foverlay_get (overlay_vec[i], Qmouse_face);
 35698               if (!NILP (mouse_face))
 35699                 overlay = overlay_vec[i];
 35700             }
 35701 
 35702           /* If we're highlighting the same overlay as before, there's
 35703              no need to do that again.  */
 35704           if (!NILP (overlay) && EQ (overlay, hlinfo->mouse_face_overlay))
 35705             goto check_help_echo;
 35706 
 35707           /* Clear the display of the old active region, if any.  */
 35708           if (clear_mouse_face (hlinfo))
 35709             cursor = No_Cursor;
 35710 
 35711           /* Record the overlay, if any, to be highlighted.  */
 35712           hlinfo->mouse_face_overlay = overlay;
 35713 
 35714           /* If no overlay applies, get a text property.  */
 35715           if (NILP (overlay))
 35716             mouse_face = Fget_text_property (position, Qmouse_face, object);
 35717 
 35718           /* Next, compute the bounds of the mouse highlighting and
 35719              display it.  */
 35720           if (!NILP (mouse_face) && STRINGP (object))
 35721             {
 35722               /* The mouse-highlighting comes from a display string
 35723                  with a mouse-face.  */
 35724               Lisp_Object s, e;
 35725               ptrdiff_t ignore;
 35726 
 35727               s = Fprevious_single_property_change
 35728                 (make_fixnum (pos + 1), Qmouse_face, object, Qnil);
 35729               e = Fnext_single_property_change
 35730                 (position, Qmouse_face, object, Qnil);
 35731               if (NILP (s))
 35732                 s = make_fixnum (0);
 35733               if (NILP (e))
 35734                 e = make_fixnum (SCHARS (object));
 35735               mouse_face_from_string_pos (w, hlinfo, object,
 35736                                           XFIXNUM (s), XFIXNUM (e));
 35737               hlinfo->mouse_face_past_end = false;
 35738               hlinfo->mouse_face_window = window;
 35739               hlinfo->mouse_face_face_id
 35740                 = face_at_string_position (w, object, pos, 0, &ignore,
 35741                                            glyph->face_id, true, 0);
 35742               show_mouse_face (hlinfo, DRAW_MOUSE_FACE);
 35743               cursor = No_Cursor;
 35744             }
 35745           else
 35746             {
 35747               /* The mouse-highlighting, if any, comes from an overlay
 35748                  or text property in the buffer.  */
 35749               Lisp_Object buffer UNINIT;
 35750               Lisp_Object disp_string UNINIT;
 35751 
 35752               if (STRINGP (object))
 35753                 {
 35754                   /* If we are on a display string with no mouse-face,
 35755                      check if the text under it has one.  */
 35756                   struct glyph_row *r = MATRIX_ROW (w->current_matrix, vpos);
 35757                   ptrdiff_t start = MATRIX_ROW_START_CHARPOS (r);
 35758                   pos = string_buffer_position (object, start);
 35759                   if (pos > 0)
 35760                     {
 35761                       mouse_face = get_char_property_and_overlay
 35762                         (make_fixnum (pos), Qmouse_face, w->contents, &overlay);
 35763                       buffer = w->contents;
 35764                       disp_string = object;
 35765                     }
 35766                 }
 35767               else
 35768                 {
 35769                   buffer = object;
 35770                   disp_string = Qnil;
 35771                 }
 35772 
 35773               if (!NILP (mouse_face))
 35774                 {
 35775                   Lisp_Object before, after;
 35776                   Lisp_Object before_string, after_string;
 35777                   /* To correctly find the limits of mouse highlight
 35778                      in a bidi-reordered buffer, we must not use the
 35779                      optimization of limiting the search in
 35780                      previous-single-property-change and
 35781                      next-single-property-change, because
 35782                      rows_from_pos_range needs the real start and end
 35783                      positions to DTRT in this case.  That's because
 35784                      the first row visible in a window does not
 35785                      necessarily display the character whose position
 35786                      is the smallest.  */
 35787                   Lisp_Object lim1
 35788                     = NILP (BVAR (XBUFFER (buffer), bidi_display_reordering))
 35789                     ? Fmarker_position (w->start)
 35790                     : Qnil;
 35791                   Lisp_Object lim2
 35792                     = NILP (BVAR (XBUFFER (buffer), bidi_display_reordering))
 35793                     ? make_fixnum (BUF_Z (XBUFFER (buffer))
 35794                                    - w->window_end_pos)
 35795                     : Qnil;
 35796 
 35797                   if (NILP (overlay))
 35798                     {
 35799                       /* Handle the text property case.  */
 35800                       before = Fprevious_single_property_change
 35801                         (make_fixnum (pos + 1), Qmouse_face, buffer, lim1);
 35802                       after = Fnext_single_property_change
 35803                         (make_fixnum (pos), Qmouse_face, buffer, lim2);
 35804                       before_string = after_string = Qnil;
 35805                     }
 35806                   else
 35807                     {
 35808                       /* Handle the overlay case.  */
 35809                       before = Foverlay_start (overlay);
 35810                       after = Foverlay_end (overlay);
 35811                       before_string = Foverlay_get (overlay, Qbefore_string);
 35812                       after_string = Foverlay_get (overlay, Qafter_string);
 35813 
 35814                       if (!STRINGP (before_string)) before_string = Qnil;
 35815                       if (!STRINGP (after_string))  after_string = Qnil;
 35816                     }
 35817 
 35818                   mouse_face_from_buffer_pos (window, hlinfo, pos,
 35819                                               NILP (before)
 35820                                               ? 1
 35821                                               : XFIXNAT (before),
 35822                                               NILP (after)
 35823                                               ? BUF_Z (XBUFFER (buffer))
 35824                                               : XFIXNAT (after),
 35825                                               before_string, after_string,
 35826                                               disp_string);
 35827                   cursor = No_Cursor;
 35828                 }
 35829             }
 35830         }
 35831 
 35832     check_help_echo:
 35833 
 35834       /* Look for a `help-echo' property.  */
 35835       if (NILP (help_echo_string)) {
 35836         Lisp_Object help, overlay;
 35837 
 35838         /* Check overlays first.  */
 35839         help = overlay = Qnil;
 35840         for (i = noverlays - 1; i >= 0 && NILP (help); --i)
 35841           {
 35842             overlay = overlay_vec[i];
 35843             help = Foverlay_get (overlay, Qhelp_echo);
 35844           }
 35845 
 35846         if (!NILP (help))
 35847           {
 35848             help_echo_string = help;
 35849             help_echo_window = window;
 35850             help_echo_object = overlay;
 35851             help_echo_pos = pos;
 35852           }
 35853         else
 35854           {
 35855             Lisp_Object obj = glyph->object;
 35856             ptrdiff_t charpos = glyph->charpos;
 35857 
 35858             /* Try text properties.  */
 35859             if (STRINGP (obj)
 35860                 && charpos >= 0
 35861                 && charpos < SCHARS (obj))
 35862               {
 35863                 help = Fget_text_property (make_fixnum (charpos),
 35864                                            Qhelp_echo, obj);
 35865                 if (NILP (help))
 35866                   {
 35867                     /* If the string itself doesn't specify a help-echo,
 35868                        see if the buffer text ``under'' it does.  */
 35869                     struct glyph_row *r
 35870                       = MATRIX_ROW (w->current_matrix, vpos);
 35871                     ptrdiff_t start = MATRIX_ROW_START_CHARPOS (r);
 35872                     ptrdiff_t p = string_buffer_position (obj, start);
 35873                     if (p > 0)
 35874                       {
 35875                         help = Fget_char_property (make_fixnum (p),
 35876                                                    Qhelp_echo, w->contents);
 35877                         if (!NILP (help))
 35878                           {
 35879                             charpos = p;
 35880                             obj = w->contents;
 35881                           }
 35882                       }
 35883                   }
 35884               }
 35885             else if (BUFFERP (obj)
 35886                      && charpos >= BEGV
 35887                      && charpos < ZV)
 35888               help = Fget_text_property (make_fixnum (charpos), Qhelp_echo,
 35889                                          obj);
 35890 
 35891             if (!NILP (help))
 35892               {
 35893                 help_echo_string = help;
 35894                 help_echo_window = window;
 35895                 help_echo_object = obj;
 35896                 help_echo_pos = charpos;
 35897               }
 35898           }
 35899       }
 35900 
 35901 #ifdef HAVE_WINDOW_SYSTEM
 35902       /* Look for a `pointer' property.  */
 35903       if (FRAME_WINDOW_P (f) && NILP (pointer))
 35904         {
 35905           /* Check overlays first.  */
 35906           for (i = noverlays - 1; i >= 0 && NILP (pointer); --i)
 35907             pointer = Foverlay_get (overlay_vec[i], Qpointer);
 35908 
 35909           if (NILP (pointer))
 35910             {
 35911               Lisp_Object obj = glyph->object;
 35912               ptrdiff_t charpos = glyph->charpos;
 35913 
 35914               /* Try text properties.  */
 35915               if (STRINGP (obj)
 35916                   && charpos >= 0
 35917                   && charpos < SCHARS (obj))
 35918                 {
 35919                   pointer = Fget_text_property (make_fixnum (charpos),
 35920                                                 Qpointer, obj);
 35921                   if (NILP (pointer))
 35922                     {
 35923                       /* If the string itself doesn't specify a pointer,
 35924                          see if the buffer text ``under'' it does.  */
 35925                       struct glyph_row *r
 35926                         = MATRIX_ROW (w->current_matrix, vpos);
 35927                       ptrdiff_t start = MATRIX_ROW_START_CHARPOS (r);
 35928                       ptrdiff_t p = string_buffer_position (obj, start);
 35929                       if (p > 0)
 35930                         pointer = Fget_char_property (make_fixnum (p),
 35931                                                       Qpointer, w->contents);
 35932                     }
 35933                 }
 35934               else if (BUFFERP (obj)
 35935                        && charpos >= BEGV
 35936                        && charpos < ZV)
 35937                 pointer = Fget_text_property (make_fixnum (charpos),
 35938                                               Qpointer, obj);
 35939             }
 35940         }
 35941 #endif  /* HAVE_WINDOW_SYSTEM */
 35942 
 35943       BEGV = obegv;
 35944       ZV = ozv;
 35945       current_buffer = obuf;
 35946       SAFE_FREE ();
 35947     }
 35948 
 35949  set_cursor:
 35950   define_frame_cursor1 (f, cursor, pointer);
 35951 }
 35952 
 35953 
 35954 /* EXPORT for RIF:
 35955    Clear any mouse-face on window W.  This function is part of the
 35956    redisplay interface, and is called from try_window_id and similar
 35957    functions to ensure the mouse-highlight is off.  */
 35958 
 35959 void
 35960 gui_clear_window_mouse_face (struct window *w)
 35961 {
 35962   Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (XFRAME (w->frame));
 35963   Lisp_Object window;
 35964 
 35965   block_input ();
 35966   XSETWINDOW (window, w);
 35967   if (EQ (window, hlinfo->mouse_face_window))
 35968     clear_mouse_face (hlinfo);
 35969   unblock_input ();
 35970 }
 35971 
 35972 
 35973 /* EXPORT:
 35974    Just discard the mouse face information for frame F, if any.
 35975    This is used when the size of F is changed.  */
 35976 
 35977 void
 35978 cancel_mouse_face (struct frame *f)
 35979 {
 35980   Lisp_Object window;
 35981   Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (f);
 35982 
 35983   window = hlinfo->mouse_face_window;
 35984   if (! NILP (window) && XFRAME (XWINDOW (window)->frame) == f)
 35985     reset_mouse_highlight (hlinfo);
 35986 }
 35987 
 35988 
 35989 
 35990 /***********************************************************************
 35991                            Exposure Events
 35992  ***********************************************************************/
 35993 
 35994 #ifdef HAVE_WINDOW_SYSTEM
 35995 
 35996 /* Redraw the part of glyph row area AREA of glyph row ROW on window W
 35997    which intersects rectangle R.  R is in window-relative coordinates.  */
 35998 
 35999 static void
 36000 expose_area (struct window *w, struct glyph_row *row, const Emacs_Rectangle *r,
 36001              enum glyph_row_area area)
 36002 {
 36003   struct glyph *first = row->glyphs[area];
 36004   struct glyph *end = row->glyphs[area] + row->used[area];
 36005   struct glyph *last;
 36006   int first_x, start_x, x;
 36007 
 36008   if (area == TEXT_AREA && row->fill_line_p)
 36009     /* If row extends face to end of line write the whole line.  */
 36010     draw_glyphs (w, row->x, row, area,
 36011                  0, row->used[area],
 36012                  DRAW_NORMAL_TEXT, 0);
 36013   else
 36014     {
 36015       /* Set START_X to the window-relative start position for drawing glyphs of
 36016          AREA.  The first glyph of the text area can be partially visible.
 36017          The first glyphs of other areas cannot.  */
 36018       start_x = window_box_left_offset (w, area);
 36019       x = start_x;
 36020       if (area == TEXT_AREA)
 36021         x += row->x;
 36022 
 36023       /* Find the first glyph that must be redrawn.  */
 36024       while (first < end
 36025              && x + first->pixel_width < r->x)
 36026         {
 36027           x += first->pixel_width;
 36028           ++first;
 36029         }
 36030 
 36031       /* Find the last one.  */
 36032       last = first;
 36033       first_x = x;
 36034       /* Use a signed int intermediate value to avoid catastrophic
 36035          failures due to comparison between signed and unsigned, when
 36036          x is negative (can happen for wide images that are hscrolled).  */
 36037       int r_end = r->x + r->width;
 36038       while (last < end && x < r_end)
 36039         {
 36040           x += last->pixel_width;
 36041           ++last;
 36042         }
 36043 
 36044       /* Repaint.  */
 36045       if (last > first)
 36046         draw_glyphs (w, first_x - start_x, row, area,
 36047                      first - row->glyphs[area], last - row->glyphs[area],
 36048                      DRAW_NORMAL_TEXT, 0);
 36049     }
 36050 }
 36051 
 36052 
 36053 /* Redraw the parts of the glyph row ROW on window W intersecting
 36054    rectangle R.  R is in window-relative coordinates.  Value is
 36055    true if mouse-face was overwritten.  */
 36056 
 36057 static bool
 36058 expose_line (struct window *w, struct glyph_row *row, const Emacs_Rectangle *r)
 36059 {
 36060   eassert (row->enabled_p);
 36061 
 36062   if (row->mode_line_p || w->pseudo_window_p)
 36063     draw_glyphs (w, 0, row, TEXT_AREA,
 36064                  0, row->used[TEXT_AREA],
 36065                  DRAW_NORMAL_TEXT, 0);
 36066   else
 36067     {
 36068       if (row->used[LEFT_MARGIN_AREA])
 36069         expose_area (w, row, r, LEFT_MARGIN_AREA);
 36070       if (row->used[TEXT_AREA])
 36071         expose_area (w, row, r, TEXT_AREA);
 36072       if (row->used[RIGHT_MARGIN_AREA])
 36073         expose_area (w, row, r, RIGHT_MARGIN_AREA);
 36074       draw_row_fringe_bitmaps (w, row);
 36075     }
 36076 
 36077   return row->mouse_face_p;
 36078 }
 36079 
 36080 
 36081 /* Redraw those parts of glyphs rows during expose event handling that
 36082    overlap other rows.  Redrawing of an exposed line writes over parts
 36083    of lines overlapping that exposed line; this function fixes that.
 36084 
 36085    W is the window being exposed.  FIRST_OVERLAPPING_ROW is the first
 36086    row in W's current matrix that is exposed and overlaps other rows.
 36087    LAST_OVERLAPPING_ROW is the last such row.  */
 36088 
 36089 static void
 36090 expose_overlaps (struct window *w,
 36091                  struct glyph_row *first_overlapping_row,
 36092                  struct glyph_row *last_overlapping_row,
 36093                  const Emacs_Rectangle *r)
 36094 {
 36095   struct glyph_row *row;
 36096 
 36097   for (row = first_overlapping_row; row <= last_overlapping_row; ++row)
 36098     if (row->overlapping_p)
 36099       {
 36100         eassert (row->enabled_p && !row->mode_line_p);
 36101 
 36102         row->clip = r;
 36103         if (row->used[LEFT_MARGIN_AREA])
 36104           gui_fix_overlapping_area (w, row, LEFT_MARGIN_AREA, OVERLAPS_BOTH);
 36105 
 36106         if (row->used[TEXT_AREA])
 36107           gui_fix_overlapping_area (w, row, TEXT_AREA, OVERLAPS_BOTH);
 36108 
 36109         if (row->used[RIGHT_MARGIN_AREA])
 36110           gui_fix_overlapping_area (w, row, RIGHT_MARGIN_AREA, OVERLAPS_BOTH);
 36111         row->clip = NULL;
 36112       }
 36113 }
 36114 
 36115 
 36116 /* Return true if W's cursor intersects rectangle R.  */
 36117 
 36118 static bool
 36119 phys_cursor_in_rect_p (struct window *w, const Emacs_Rectangle *r)
 36120 {
 36121   Emacs_Rectangle cr, result;
 36122   struct glyph *cursor_glyph;
 36123   struct glyph_row *row;
 36124 
 36125   if (w->phys_cursor.vpos >= 0
 36126       && w->phys_cursor.vpos < w->current_matrix->nrows
 36127       && (row = MATRIX_ROW (w->current_matrix, w->phys_cursor.vpos),
 36128           row->enabled_p)
 36129       && row->cursor_in_fringe_p)
 36130     {
 36131       /* Cursor is in the fringe.  */
 36132       cr.x = window_box_right_offset (w,
 36133                                       (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
 36134                                        ? RIGHT_MARGIN_AREA
 36135                                        : TEXT_AREA));
 36136       cr.y = row->y;
 36137       cr.width = WINDOW_RIGHT_FRINGE_WIDTH (w);
 36138       cr.height = row->height;
 36139       return gui_intersect_rectangles (&cr, r, &result);
 36140     }
 36141 
 36142   cursor_glyph = get_phys_cursor_glyph (w);
 36143   if (cursor_glyph)
 36144     {
 36145       /* r is relative to W's box, but w->phys_cursor.x is relative
 36146          to left edge of W's TEXT area.  Adjust it.  */
 36147       cr.x = window_box_left_offset (w, TEXT_AREA) + w->phys_cursor.x;
 36148       cr.y = w->phys_cursor.y;
 36149       cr.width = cursor_glyph->pixel_width;
 36150       cr.height = w->phys_cursor_height;
 36151       /* ++KFS: W32 version used W32-specific IntersectRect here, but
 36152          I assume the effect is the same -- and this is portable.  */
 36153       return gui_intersect_rectangles (&cr, r, &result);
 36154     }
 36155   /* If we don't understand the format, pretend we're not in the hot-spot.  */
 36156   return false;
 36157 }
 36158 
 36159 
 36160 /* EXPORT:
 36161    Draw a vertical window border to the right of window W if W doesn't
 36162    have vertical scroll bars.  */
 36163 
 36164 void
 36165 gui_draw_vertical_border (struct window *w)
 36166 {
 36167   struct frame *f = XFRAME (WINDOW_FRAME (w));
 36168 
 36169   /* We could do better, if we knew what type of scroll-bar the adjacent
 36170      windows (on either side) have...  But we don't :-(
 36171      However, I think this works ok.  ++KFS 2003-04-25 */
 36172 
 36173   /* Redraw borders between horizontally adjacent windows.  Don't
 36174      do it for frames with vertical scroll bars because either the
 36175      right scroll bar of a window, or the left scroll bar of its
 36176      neighbor will suffice as a border.  */
 36177   if (FRAME_HAS_VERTICAL_SCROLL_BARS (f) || FRAME_RIGHT_DIVIDER_WIDTH (f))
 36178     return;
 36179 
 36180   /* Note: It is necessary to redraw both the left and the right
 36181      borders, for when only this single window W is being
 36182      redisplayed.  */
 36183   if (!WINDOW_RIGHTMOST_P (w)
 36184       && !WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT (w))
 36185     {
 36186       int x0, x1, y0, y1;
 36187 
 36188       window_box_edges (w, &x0, &y0, &x1, &y1);
 36189       y1 -= 1;
 36190 
 36191       if (WINDOW_LEFT_FRINGE_WIDTH (w) == 0)
 36192         x1 -= 1;
 36193 
 36194       FRAME_RIF (f)->draw_vertical_window_border (w, x1, y0, y1);
 36195     }
 36196 
 36197   if (!WINDOW_LEFTMOST_P (w)
 36198       && !WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w))
 36199     {
 36200       int x0, x1, y0, y1;
 36201 
 36202       window_box_edges (w, &x0, &y0, &x1, &y1);
 36203       y1 -= 1;
 36204 
 36205       if (WINDOW_LEFT_FRINGE_WIDTH (w) == 0)
 36206         x0 -= 1;
 36207 
 36208       FRAME_RIF (f)->draw_vertical_window_border (w, x0, y0, y1);
 36209     }
 36210 }
 36211 
 36212 
 36213 /* Draw window dividers for window W.  */
 36214 
 36215 void
 36216 gui_draw_right_divider (struct window *w)
 36217 {
 36218   struct frame *f = WINDOW_XFRAME (w);
 36219 
 36220   if (w->mini || w->pseudo_window_p)
 36221     return;
 36222   else if (WINDOW_RIGHT_DIVIDER_WIDTH (w))
 36223     {
 36224       int x0 = WINDOW_RIGHT_EDGE_X (w) - WINDOW_RIGHT_DIVIDER_WIDTH (w);
 36225       int x1 = WINDOW_RIGHT_EDGE_X (w);
 36226       int y0 = WINDOW_TOP_EDGE_Y (w);
 36227       int y1 = WINDOW_BOTTOM_EDGE_Y (w);
 36228 
 36229       /* If W is horizontally combined and has a right sibling, don't
 36230          draw over any bottom divider.  */
 36231       if (WINDOW_BOTTOM_DIVIDER_WIDTH (w)
 36232           && !NILP (w->parent)
 36233           && WINDOW_HORIZONTAL_COMBINATION_P (XWINDOW (w->parent))
 36234           && !NILP (w->next))
 36235         y1 -= WINDOW_BOTTOM_DIVIDER_WIDTH (w);
 36236 
 36237       FRAME_RIF (f)->draw_window_divider (w, x0, x1, y0, y1);
 36238     }
 36239 }
 36240 
 36241 static void
 36242 gui_draw_bottom_divider (struct window *w)
 36243 {
 36244   struct frame *f = XFRAME (WINDOW_FRAME (w));
 36245 
 36246   if (w->mini || w->pseudo_window_p)
 36247     return;
 36248   else if (WINDOW_BOTTOM_DIVIDER_WIDTH (w))
 36249     {
 36250       int x0 = WINDOW_LEFT_EDGE_X (w);
 36251       int x1 = WINDOW_RIGHT_EDGE_X (w);
 36252       int y0 = WINDOW_BOTTOM_EDGE_Y (w) - WINDOW_BOTTOM_DIVIDER_WIDTH (w);
 36253       int y1 = WINDOW_BOTTOM_EDGE_Y (w);
 36254       struct window *p = !NILP (w->parent) ? XWINDOW (w->parent) : NULL;
 36255 
 36256       /* If W is vertically combined and has a sibling below, don't draw
 36257          over any right divider.  */
 36258       if (WINDOW_RIGHT_DIVIDER_WIDTH (w)
 36259           && p
 36260           && ((WINDOW_VERTICAL_COMBINATION_P (p)
 36261                && !NILP (w->next))
 36262               || (WINDOW_HORIZONTAL_COMBINATION_P (p)
 36263                   && NILP (w->next)
 36264                   && !NILP (p->parent)
 36265                   && WINDOW_VERTICAL_COMBINATION_P (XWINDOW (p->parent))
 36266                   && !NILP (XWINDOW (p->parent)->next))))
 36267         x1 -= WINDOW_RIGHT_DIVIDER_WIDTH (w);
 36268 
 36269       FRAME_RIF (f)->draw_window_divider (w, x0, x1, y0, y1);
 36270     }
 36271 }
 36272 
 36273 /* Redraw the part of window W intersection rectangle FR.  Pixel
 36274    coordinates in FR are frame-relative.  Call this function with
 36275    input blocked.  Value is true if the exposure overwrites
 36276    mouse-face.  */
 36277 
 36278 static bool
 36279 expose_window (struct window *w, const Emacs_Rectangle *fr)
 36280 {
 36281   struct frame *f = XFRAME (w->frame);
 36282   Emacs_Rectangle wr, r;
 36283   bool mouse_face_overwritten_p = false;
 36284 
 36285   /* If window is not yet fully initialized, do nothing.  This can
 36286      happen when toolkit scroll bars are used and a window is split.
 36287      Reconfiguring the scroll bar will generate an expose for a newly
 36288      created window.  */
 36289   if (w->current_matrix == NULL)
 36290     return false;
 36291 
 36292   /* When we're currently updating the window, display and current
 36293      matrix usually don't agree.  Arrange for a thorough display
 36294      later.  */
 36295   if (w->must_be_updated_p)
 36296     {
 36297       SET_FRAME_GARBAGED (f);
 36298       return false;
 36299     }
 36300 
 36301   /* Frame-relative pixel rectangle of W.  */
 36302   wr.x = WINDOW_LEFT_EDGE_X (w);
 36303   wr.y = WINDOW_TOP_EDGE_Y (w);
 36304   wr.width = WINDOW_PIXEL_WIDTH (w);
 36305   wr.height = WINDOW_PIXEL_HEIGHT (w);
 36306 
 36307   if (gui_intersect_rectangles (fr, &wr, &r))
 36308     {
 36309       int yb = window_text_bottom_y (w);
 36310       struct glyph_row *row;
 36311       struct glyph_row *first_overlapping_row, *last_overlapping_row;
 36312 
 36313       redisplay_trace ("expose_window (%d, %d, %u, %u)\n",
 36314                        r.x, r.y, r.width, r.height);
 36315 
 36316       /* Convert to window coordinates.  */
 36317       r.x -= WINDOW_LEFT_EDGE_X (w);
 36318       r.y -= WINDOW_TOP_EDGE_Y (w);
 36319 
 36320       /* Turn off the cursor.  */
 36321       bool cursor_cleared_p = (!w->pseudo_window_p
 36322                                && phys_cursor_in_rect_p (w, &r));
 36323       if (cursor_cleared_p)
 36324         gui_clear_cursor (w);
 36325 
 36326       /* If the row containing the cursor extends face to end of line,
 36327          then expose_area might overwrite the cursor outside the
 36328          rectangle and thus notice_overwritten_cursor might clear
 36329          w->phys_cursor_on_p.  We remember the original value and
 36330          check later if it is changed.  */
 36331       bool phys_cursor_on_p = w->phys_cursor_on_p;
 36332 
 36333       /* Use a signed int intermediate value to avoid catastrophic
 36334          failures due to comparison between signed and unsigned, when
 36335          y0 or y1 is negative (can happen for tall images).  */
 36336       int r_bottom = r.y + r.height;
 36337 
 36338       /* We must temporarily switch to the window's buffer, in case
 36339          the fringe face has been remapped in that buffer's
 36340          face-remapping-alist, so that draw_row_fringe_bitmaps,
 36341          called from expose_line, will use the right face.  */
 36342       bool buffer_changed = false;
 36343       struct buffer *oldbuf = current_buffer;
 36344       if (!w->pseudo_window_p)
 36345         {
 36346           set_buffer_internal_1 (XBUFFER (w->contents));
 36347           buffer_changed = true;
 36348         }
 36349 
 36350       /* Update lines intersecting rectangle R.  */
 36351       first_overlapping_row = last_overlapping_row = NULL;
 36352       for (row = w->current_matrix->rows;
 36353            row->enabled_p;
 36354            ++row)
 36355         {
 36356           int y0 = row->y;
 36357           int y1 = MATRIX_ROW_BOTTOM_Y (row);
 36358 
 36359           if ((y0 >= r.y && y0 < r_bottom)
 36360               || (y1 > r.y && y1 < r_bottom)
 36361               || (r.y >= y0 && r.y < y1)
 36362               || (r_bottom > y0 && r_bottom < y1))
 36363             {
 36364               /* A header line may be overlapping, but there is no need
 36365                  to fix overlapping areas for them.  KFS 2005-02-12 */
 36366               if (row->overlapping_p && !row->mode_line_p)
 36367                 {
 36368                   if (first_overlapping_row == NULL)
 36369                     first_overlapping_row = row;
 36370                   last_overlapping_row = row;
 36371                 }
 36372 
 36373               row->clip = fr;
 36374               if (expose_line (w, row, &r))
 36375                 mouse_face_overwritten_p = true;
 36376               row->clip = NULL;
 36377             }
 36378           else if (row->overlapping_p)
 36379             {
 36380               /* We must redraw a row overlapping the exposed area.  */
 36381               if (y0 < r.y
 36382                   ? y0 + row->phys_height > r.y
 36383                   : y0 + row->ascent - row->phys_ascent < r.y +r.height)
 36384                 {
 36385                   if (first_overlapping_row == NULL)
 36386                     first_overlapping_row = row;
 36387                   last_overlapping_row = row;
 36388                 }
 36389             }
 36390 
 36391           if (y1 >= yb)
 36392             break;
 36393         }
 36394 
 36395       if (buffer_changed)
 36396         set_buffer_internal_1 (oldbuf);
 36397 
 36398       /* Display the mode line if there is one.  */
 36399       if (window_wants_mode_line (w)
 36400           && (row = MATRIX_MODE_LINE_ROW (w->current_matrix),
 36401               row->enabled_p)
 36402           && row->y < r_bottom)
 36403         {
 36404           if (expose_line (w, row, &r))
 36405             mouse_face_overwritten_p = true;
 36406         }
 36407 
 36408       if (!w->pseudo_window_p)
 36409         {
 36410           /* Fix the display of overlapping rows.  */
 36411           if (first_overlapping_row)
 36412             expose_overlaps (w, first_overlapping_row, last_overlapping_row,
 36413                              fr);
 36414 
 36415           /* Draw border between windows.  */
 36416           if (WINDOW_RIGHT_DIVIDER_WIDTH (w))
 36417             gui_draw_right_divider (w);
 36418           else
 36419             gui_draw_vertical_border (w);
 36420 
 36421           if (WINDOW_BOTTOM_DIVIDER_WIDTH (w))
 36422             gui_draw_bottom_divider (w);
 36423 
 36424           /* Turn the cursor on again.  */
 36425           if (cursor_cleared_p
 36426               || (phys_cursor_on_p && !w->phys_cursor_on_p))
 36427             update_window_cursor (w, true);
 36428         }
 36429     }
 36430 
 36431   return mouse_face_overwritten_p;
 36432 }
 36433 
 36434 
 36435 
 36436 /* Redraw (parts) of all windows in the window tree rooted at W that
 36437    intersect R.  R contains frame pixel coordinates.  Value is
 36438    true if the exposure overwrites mouse-face.  */
 36439 
 36440 static bool
 36441 expose_window_tree (struct window *w, const Emacs_Rectangle *r)
 36442 {
 36443   struct frame *f = XFRAME (w->frame);
 36444   bool mouse_face_overwritten_p = false;
 36445 
 36446   while (w && !FRAME_GARBAGED_P (f))
 36447     {
 36448       mouse_face_overwritten_p
 36449         |= (WINDOWP (w->contents)
 36450             ? expose_window_tree (XWINDOW (w->contents), r)
 36451             : expose_window (w, r));
 36452 
 36453       w = NILP (w->next) ? NULL : XWINDOW (w->next);
 36454     }
 36455 
 36456   return mouse_face_overwritten_p;
 36457 }
 36458 
 36459 
 36460 /* EXPORT:
 36461    Redisplay an exposed area of frame F.  X and Y are the upper-left
 36462    corner of the exposed rectangle.  W and H are width and height of
 36463    the exposed area.  All are pixel values.  W or H zero means redraw
 36464    the entire frame.  */
 36465 
 36466 void
 36467 expose_frame (struct frame *f, int x, int y, int w, int h)
 36468 {
 36469   Emacs_Rectangle r;
 36470   bool mouse_face_overwritten_p = false;
 36471 
 36472   if (FRAME_GARBAGED_P (f))
 36473     {
 36474       redisplay_trace ("expose_frame garbaged\n");
 36475       return;
 36476     }
 36477 
 36478   /* If basic faces haven't been realized yet, there is no point in
 36479      trying to redraw anything.  This can happen when we get an expose
 36480      event while Emacs is starting, e.g. by moving another window.  */
 36481   if (FRAME_FACE_CACHE (f) == NULL
 36482       || FRAME_FACE_CACHE (f)->used < BASIC_FACE_ID_SENTINEL)
 36483     {
 36484       redisplay_trace ("expose_frame no faces\n");
 36485       return;
 36486     }
 36487 
 36488   if (w == 0 || h == 0)
 36489     {
 36490       r.x = r.y = 0;
 36491       r.width = FRAME_TEXT_WIDTH (f);
 36492       r.height = FRAME_TEXT_HEIGHT (f);
 36493     }
 36494   else
 36495     {
 36496       r.x = x;
 36497       r.y = y;
 36498       r.width = w;
 36499       r.height = h;
 36500     }
 36501 
 36502   redisplay_trace ("expose_frame (%d, %d, %u, %u)\n",
 36503                    r.x, r.y, r.width, r.height);
 36504   mouse_face_overwritten_p = expose_window_tree (XWINDOW (f->root_window), &r);
 36505 
 36506   if (WINDOWP (f->tab_bar_window))
 36507     mouse_face_overwritten_p
 36508       |= expose_window (XWINDOW (f->tab_bar_window), &r);
 36509 
 36510 #ifndef HAVE_EXT_TOOL_BAR
 36511   if (WINDOWP (f->tool_bar_window))
 36512     mouse_face_overwritten_p
 36513       |= expose_window (XWINDOW (f->tool_bar_window), &r);
 36514 #endif
 36515 
 36516 #if defined HAVE_WINDOW_SYSTEM && !defined HAVE_EXT_MENU_BAR
 36517   if (WINDOWP (f->menu_bar_window))
 36518     mouse_face_overwritten_p
 36519       |= expose_window (XWINDOW (f->menu_bar_window), &r);
 36520 #endif
 36521 
 36522   /* Some window managers support a focus-follows-mouse style with
 36523      delayed raising of frames.  Imagine a partially obscured frame,
 36524      and moving the mouse into partially obscured mouse-face on that
 36525      frame.  The visible part of the mouse-face will be highlighted,
 36526      then the WM raises the obscured frame.  With at least one WM, KDE
 36527      2.1, Emacs is not getting any event for the raising of the frame
 36528      (even tried with SubstructureRedirectMask), only Expose events.
 36529      These expose events will draw text normally, i.e. not
 36530      highlighted.  Which means we must redo the highlight here.
 36531      Subsume it under ``we love X''.  --gerd 2001-08-15  */
 36532   /* Included in Windows version because Windows most likely does not
 36533      do the right thing if any third party tool offers
 36534      focus-follows-mouse with delayed raise.  --jason 2001-10-12  */
 36535   if (mouse_face_overwritten_p && !FRAME_GARBAGED_P (f))
 36536     {
 36537       Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (f);
 36538       if (f == hlinfo->mouse_face_mouse_frame)
 36539         {
 36540           int mouse_x = hlinfo->mouse_face_mouse_x;
 36541           int mouse_y = hlinfo->mouse_face_mouse_y;
 36542           clear_mouse_face (hlinfo);
 36543           note_mouse_highlight (f, mouse_x, mouse_y);
 36544         }
 36545     }
 36546 }
 36547 
 36548 
 36549 /* EXPORT:
 36550    Determine the intersection of two rectangles R1 and R2.  Return
 36551    the intersection in *RESULT.  Value is true if RESULT is not
 36552    empty.  */
 36553 
 36554 bool
 36555 gui_intersect_rectangles (const Emacs_Rectangle *r1, const Emacs_Rectangle *r2,
 36556                           Emacs_Rectangle *result)
 36557 {
 36558   const Emacs_Rectangle *left, *right;
 36559   const Emacs_Rectangle *upper, *lower;
 36560   bool intersection_p = false;
 36561 
 36562   /* Rearrange so that R1 is the left-most rectangle.  */
 36563   if (r1->x < r2->x)
 36564     left = r1, right = r2;
 36565   else
 36566     left = r2, right = r1;
 36567 
 36568   /* X0 of the intersection is right.x0, if this is inside R1,
 36569      otherwise there is no intersection.  */
 36570   if (right->x <= left->x + left->width)
 36571     {
 36572       result->x = right->x;
 36573 
 36574       /* The right end of the intersection is the minimum of
 36575          the right ends of left and right.  */
 36576       result->width = (min (left->x + left->width, right->x + right->width)
 36577                        - result->x);
 36578 
 36579       /* Same game for Y.  */
 36580       if (r1->y < r2->y)
 36581         upper = r1, lower = r2;
 36582       else
 36583         upper = r2, lower = r1;
 36584 
 36585       /* The upper end of the intersection is lower.y0, if this is inside
 36586          of upper.  Otherwise, there is no intersection.  */
 36587       if (lower->y <= upper->y + upper->height)
 36588         {
 36589           result->y = lower->y;
 36590 
 36591           /* The lower end of the intersection is the minimum of the lower
 36592              ends of upper and lower.  */
 36593           result->height = (min (lower->y + lower->height,
 36594                                  upper->y + upper->height)
 36595                             - result->y);
 36596           intersection_p = true;
 36597         }
 36598     }
 36599 
 36600   return intersection_p;
 36601 }
 36602 
 36603 /* EXPORT:
 36604    Determine the union of the rectangles A and B.  Return the smallest
 36605    rectangle encompassing both the bounds of A and B in *RESULT.  It
 36606    is safe for all three arguments to point to each other.  */
 36607 
 36608 void
 36609 gui_union_rectangles (const Emacs_Rectangle *a, const Emacs_Rectangle *b,
 36610                       Emacs_Rectangle *result)
 36611 {
 36612   struct gui_box a_box, b_box, result_box;
 36613 
 36614   /* Handle special cases where one of the rectangles is empty.  */
 36615 
 36616   if (!a->width || !a->height)
 36617     {
 36618       *result = *b;
 36619       return;
 36620     }
 36621   else if (!b->width || !b->height)
 36622     {
 36623       *result = *a;
 36624       return;
 36625     }
 36626 
 36627   /* Convert A and B to boxes.  */
 36628   a_box.x1 = a->x;
 36629   a_box.y1 = a->y;
 36630   a_box.x2 = a->x + a->width;
 36631   a_box.y2 = a->y + a->height;
 36632 
 36633   b_box.x1 = b->x;
 36634   b_box.y1 = b->y;
 36635   b_box.x2 = b->x + b->width;
 36636   b_box.y2 = b->y + b->height;
 36637 
 36638   /* Compute the union of the boxes.  */
 36639   result_box.x1 = min (a_box.x1, b_box.x1);
 36640   result_box.y1 = min (a_box.y1, b_box.y1);
 36641   result_box.x2 = max (a_box.x2, b_box.x2);
 36642   result_box.y2 = max (a_box.y2, b_box.y2);
 36643 
 36644   /* Convert result_box to an XRectangle and put the result in
 36645      RESULT.  */
 36646   result->x = result_box.x1;
 36647   result->y = result_box.y1;
 36648   result->width = result_box.x2 - result_box.x1;
 36649   result->height = result_box.y2 - result_box.y1;
 36650 }
 36651 
 36652 #endif /* HAVE_WINDOW_SYSTEM */
 36653 
 36654 
 36655 /***********************************************************************
 36656                             Initialization
 36657  ***********************************************************************/
 36658 
 36659 void
 36660 syms_of_xdisp (void)
 36661 {
 36662   Vwith_echo_area_save_vector = Qnil;
 36663   staticpro (&Vwith_echo_area_save_vector);
 36664 
 36665   Vmessage_stack = Qnil;
 36666   staticpro (&Vmessage_stack);
 36667 
 36668   /* Non-nil means don't actually do any redisplay.  */
 36669   DEFSYM (Qinhibit_redisplay, "inhibit-redisplay");
 36670 
 36671   DEFSYM (Qredisplay_internal_xC_functionx, "redisplay_internal (C function)");
 36672 
 36673   DEFVAR_BOOL ("scroll-minibuffer-conservatively",
 36674                scroll_minibuffer_conservatively,
 36675                doc: /* Non-nil means scroll conservatively in minibuffer windows.
 36676 When the value is nil, scrolling in minibuffer windows obeys the
 36677 settings of `scroll-conservatively'.  */);
 36678   scroll_minibuffer_conservatively = true; /* bug#44070 */
 36679 
 36680   DEFVAR_BOOL ("inhibit-message", inhibit_message,
 36681               doc:  /* Non-nil means calls to `message' are not displayed.
 36682 They are still logged to the *Messages* buffer.
 36683 
 36684 Do NOT set this globally to a non-nil value, as doing that will
 36685 disable messages everywhere, including in I-search and other
 36686 places where they are necessary.  This variable is intended to
 36687 be let-bound around code that needs to disable messages temporarily. */);
 36688   inhibit_message = false;
 36689 
 36690   message_dolog_marker1 = Fmake_marker ();
 36691   staticpro (&message_dolog_marker1);
 36692   message_dolog_marker2 = Fmake_marker ();
 36693   staticpro (&message_dolog_marker2);
 36694   message_dolog_marker3 = Fmake_marker ();
 36695   staticpro (&message_dolog_marker3);
 36696 
 36697   defsubr (&Sset_buffer_redisplay);
 36698 #ifdef GLYPH_DEBUG
 36699   defsubr (&Sdump_frame_glyph_matrix);
 36700   defsubr (&Sdump_glyph_matrix);
 36701   defsubr (&Sdump_glyph_row);
 36702   defsubr (&Sdump_tab_bar_row);
 36703   defsubr (&Sdump_tool_bar_row);
 36704   defsubr (&Strace_redisplay);
 36705   defsubr (&Strace_to_stderr);
 36706 #endif
 36707 #ifdef HAVE_WINDOW_SYSTEM
 36708   defsubr (&Stab_bar_height);
 36709   defsubr (&Stool_bar_height);
 36710   defsubr (&Slookup_image_map);
 36711 #endif
 36712   defsubr (&Sline_pixel_height);
 36713   defsubr (&Sformat_mode_line);
 36714   defsubr (&Sinvisible_p);
 36715   defsubr (&Scurrent_bidi_paragraph_direction);
 36716   defsubr (&Swindow_text_pixel_size);
 36717   defsubr (&Sbuffer_text_pixel_size);
 36718   defsubr (&Smove_point_visually);
 36719   defsubr (&Sbidi_find_overridden_directionality);
 36720   defsubr (&Sdisplay__line_is_continued_p);
 36721   defsubr (&Sget_display_property);
 36722   defsubr (&Slong_line_optimizations_p);
 36723 
 36724   DEFSYM (Qmenu_bar_update_hook, "menu-bar-update-hook");
 36725   DEFSYM (Qoverriding_terminal_local_map, "overriding-terminal-local-map");
 36726   DEFSYM (Qoverriding_local_map, "overriding-local-map");
 36727   DEFSYM (Qwindow_scroll_functions, "window-scroll-functions");
 36728   DEFSYM (Qinhibit_point_motion_hooks, "inhibit-point-motion-hooks");
 36729   DEFSYM (Qeval, "eval");
 36730   DEFSYM (QCdata, ":data");
 36731 
 36732   /* Names of text properties relevant for redisplay.  */
 36733   DEFSYM (Qdisplay, "display");
 36734   DEFSYM (Qspace_width, "space-width");
 36735   DEFSYM (Qraise, "raise");
 36736   DEFSYM (Qslice, "slice");
 36737   DEFSYM (Qspace, "space");
 36738   DEFSYM (Qmargin, "margin");
 36739   DEFSYM (Qpointer, "pointer");
 36740   DEFSYM (Qleft_margin, "left-margin");
 36741   DEFSYM (Qright_margin, "right-margin");
 36742   DEFSYM (Qcenter, "center");
 36743   DEFSYM (Qline_height, "line-height");
 36744   DEFSYM (QCalign_to, ":align-to");
 36745   DEFSYM (QCrelative_width, ":relative-width");
 36746   DEFSYM (QCrelative_height, ":relative-height");
 36747   DEFSYM (QCeval, ":eval");
 36748   DEFSYM (QCpropertize, ":propertize");
 36749   DEFSYM (QCfile, ":file");
 36750   DEFSYM (Qfontified, "fontified");
 36751   DEFSYM (Qfontification_functions, "fontification-functions");
 36752   DEFSYM (Qlong_line_optimizations_in_fontification_functions,
 36753           "long-line-optimizations-in-fontification-functions");
 36754 
 36755   /* Name of the symbol which disables Lisp evaluation in 'display'
 36756      properties.  This is used by enriched.el.  */
 36757   DEFSYM (Qdisable_eval, "disable-eval");
 36758 
 36759   /* Name of the face used to highlight trailing whitespace.  */
 36760   DEFSYM (Qtrailing_whitespace, "trailing-whitespace");
 36761 
 36762   /* Names of the faces used to display line numbers.  */
 36763   DEFSYM (Qline_number, "line-number");
 36764   DEFSYM (Qline_number_current_line, "line-number-current-line");
 36765   DEFSYM (Qline_number_major_tick, "line-number-major-tick");
 36766   DEFSYM (Qline_number_minor_tick, "line-number-minor-tick");
 36767   /* Name of a text property which disables line-number display.  */
 36768   DEFSYM (Qdisplay_line_numbers_disable, "display-line-numbers-disable");
 36769 
 36770   /* Name of the face used to display fill column indicator character.  */
 36771   DEFSYM (Qfill_column_indicator, "fill-column-indicator");
 36772 
 36773   /* Name and number of the face used to highlight escape glyphs.  */
 36774   DEFSYM (Qescape_glyph, "escape-glyph");
 36775 
 36776   /* Name and number of the face used to highlight non-breaking
 36777      spaces/hyphens.  */
 36778   DEFSYM (Qnobreak_space, "nobreak-space");
 36779   DEFSYM (Qnobreak_hyphen, "nobreak-hyphen");
 36780 
 36781   /* The symbol 'image' which is the car of the lists used to represent
 36782      images in Lisp.  Also a tool bar style.  */
 36783   DEFSYM (Qimage, "image");
 36784 
 36785   /* Tool bar styles.  */
 36786   DEFSYM (Qtext, "text");
 36787   DEFSYM (Qboth, "both");
 36788   DEFSYM (Qboth_horiz, "both-horiz");
 36789   DEFSYM (Qtext_image_horiz, "text-image-horiz");
 36790 
 36791   /* The image map types.  */
 36792   DEFSYM (QCmap, ":map");
 36793   DEFSYM (QCpointer, ":pointer");
 36794   DEFSYM (Qrect, "rect");
 36795   DEFSYM (Qcircle, "circle");
 36796   DEFSYM (Qpoly, "poly");
 36797 
 36798   DEFSYM (Qinhibit_menubar_update, "inhibit-menubar-update");
 36799 
 36800   DEFSYM (Qgrow_only, "grow-only");
 36801   DEFSYM (Qinhibit_eval_during_redisplay, "inhibit-eval-during-redisplay");
 36802   DEFSYM (Qposition, "position");
 36803   DEFSYM (Qbuffer_position, "buffer-position");
 36804   DEFSYM (Qobject, "object");
 36805 
 36806   /* Cursor shapes.  */
 36807   DEFSYM (Qbar, "bar");
 36808   DEFSYM (Qhbar, "hbar");
 36809   DEFSYM (Qbox, "box");
 36810   DEFSYM (Qhollow, "hollow");
 36811 
 36812   /* Pointer shapes.  */
 36813   DEFSYM (Qhand, "hand");
 36814   DEFSYM (Qarrow, "arrow");
 36815   /* also Qtext */
 36816 
 36817   DEFSYM (Qdragging, "dragging");
 36818   DEFSYM (Qdropping, "dropping");
 36819   DEFSYM (Qdrag_source, "drag-source");
 36820 
 36821   DEFSYM (Qdrag_with_mode_line, "drag-with-mode-line");
 36822   DEFSYM (Qdrag_with_header_line, "drag-with-header-line");
 36823   DEFSYM (Qdrag_with_tab_line, "drag-with-tab-line");
 36824 
 36825   DEFSYM (Qinhibit_free_realized_faces, "inhibit-free-realized-faces");
 36826 
 36827   list_of_error = list1 (Qerror);
 36828   staticpro (&list_of_error);
 36829 
 36830   /* Values of those variables at last redisplay are stored as
 36831      properties on 'overlay-arrow-position' symbol.  However, if
 36832      Voverlay_arrow_position is a marker, last-arrow-position is its
 36833      numerical position.  */
 36834   DEFSYM (Qlast_arrow_position, "last-arrow-position");
 36835   DEFSYM (Qlast_arrow_string, "last-arrow-string");
 36836 
 36837   /* Alternative overlay-arrow-string and overlay-arrow-bitmap
 36838      properties on a symbol in overlay-arrow-variable-list.  */
 36839   DEFSYM (Qoverlay_arrow_string, "overlay-arrow-string");
 36840   DEFSYM (Qoverlay_arrow_bitmap, "overlay-arrow-bitmap");
 36841 
 36842   echo_buffer[0] = echo_buffer[1] = Qnil;
 36843   staticpro (&echo_buffer[0]);
 36844   staticpro (&echo_buffer[1]);
 36845 
 36846   echo_area_buffer[0] = echo_area_buffer[1] = Qnil;
 36847   staticpro (&echo_area_buffer[0]);
 36848   staticpro (&echo_area_buffer[1]);
 36849 
 36850   DEFVAR_LISP ("messages-buffer-name", Vmessages_buffer_name,
 36851     doc: /* The name of the buffer where messages are logged.
 36852 This is normally \"\*Messages*\", but can be rebound by packages that
 36853 wish to redirect messages to a different buffer.  (If the buffer
 36854 doesn't exist, it will be created and put into
 36855 `messages-buffer-mode'.)  */);
 36856   Vmessages_buffer_name = build_string ("*Messages*");
 36857 
 36858   mode_line_proptrans_alist = Qnil;
 36859   staticpro (&mode_line_proptrans_alist);
 36860   mode_line_string_list = Qnil;
 36861   staticpro (&mode_line_string_list);
 36862   mode_line_string_face = Qnil;
 36863   staticpro (&mode_line_string_face);
 36864   mode_line_string_face_prop = Qnil;
 36865   staticpro (&mode_line_string_face_prop);
 36866   Vmode_line_unwind_vector = Qnil;
 36867   staticpro (&Vmode_line_unwind_vector);
 36868 
 36869   DEFSYM (Qmode_line_default_help_echo, "mode-line-default-help-echo");
 36870 
 36871   help_echo_string = Qnil;
 36872   staticpro (&help_echo_string);
 36873   help_echo_object = Qnil;
 36874   staticpro (&help_echo_object);
 36875   help_echo_window = Qnil;
 36876   staticpro (&help_echo_window);
 36877   previous_help_echo_string = Qnil;
 36878   staticpro (&previous_help_echo_string);
 36879   help_echo_pos = -1;
 36880 
 36881   DEFSYM (Qright_to_left, "right-to-left");
 36882   DEFSYM (Qleft_to_right, "left-to-right");
 36883   defsubr (&Sbidi_resolved_levels);
 36884 
 36885 #ifdef HAVE_WINDOW_SYSTEM
 36886   DEFVAR_BOOL ("x-stretch-cursor", x_stretch_cursor_p,
 36887     doc: /* Non-nil means draw block cursor as wide as the glyph under it.
 36888 For example, if a block cursor is over a tab, it will be drawn as
 36889 wide as that tab on the display.  */);
 36890   x_stretch_cursor_p = 0;
 36891 #endif
 36892 
 36893   DEFVAR_LISP ("show-trailing-whitespace", Vshow_trailing_whitespace,
 36894     doc: /* Non-nil means highlight trailing whitespace.
 36895 The face used for trailing whitespace is `trailing-whitespace'.  */);
 36896   Vshow_trailing_whitespace = Qnil;
 36897 
 36898   DEFVAR_LISP ("mode-line-compact", Vmode_line_compact,
 36899     doc: /* Non-nil means that mode lines should be compact.
 36900 This means that repeating spaces will be replaced with a single space.
 36901 If this variable is `long', only mode lines that are wider than the
 36902 currently selected window are compressed. */);
 36903   Vmode_line_compact = Qnil;
 36904   DEFSYM (Qlong, "long");
 36905 
 36906   DEFVAR_LISP ("nobreak-char-display", Vnobreak_char_display,
 36907     doc: /* Control highlighting of non-ASCII space and hyphen chars.
 36908 If the value is t, Emacs highlights non-ASCII chars which have the
 36909 same appearance as an ASCII space or hyphen, using the `nobreak-space'
 36910 or `nobreak-hyphen' face respectively.
 36911 
 36912 All of the non-ASCII characters in the Unicode horizontal whitespace
 36913 character class, as well as U+00AD (soft hyphen), U+2010 (hyphen), and
 36914 U+2011 (non-breaking hyphen) are affected.
 36915 
 36916 Any other non-nil value means to display these characters as an escape
 36917 glyph followed by an ordinary space or hyphen.
 36918 
 36919 A value of nil means no special handling of these characters.  */);
 36920   Vnobreak_char_display = Qt;
 36921 
 36922   DEFVAR_BOOL ("nobreak-char-ascii-display", nobreak_char_ascii_display,
 36923     doc: /* Control display of non-ASCII space and hyphen chars.
 36924 If the value of this variable is nil, the default, Emacs displays
 36925 non-ASCII chars which have the same appearance as an ASCII space
 36926 or hyphen as themselves, with the `nobreak-space' or `nobreak-hyphen'
 36927 face, respectively.
 36928 
 36929 If the value is t, these characters are displayed as their ASCII
 36930 counterparts: whitespace characters as ASCII space, hyphen characters
 36931 as ASCII hyphen (a.k.a. \"dash\"), using the `nobreak-space' or
 36932 the `nobreak-hyphen' face.
 36933 
 36934 This variable has effect only if `nobreak-char-display' is t;
 36935 otherwise it is ignored.
 36936 
 36937 All of the non-ASCII characters in the Unicode horizontal whitespace
 36938 character class, as well as U+00AD (soft hyphen), U+2010 (hyphen), and
 36939 U+2011 (non-breaking hyphen) are affected.  */);
 36940   nobreak_char_ascii_display = false;
 36941 
 36942   DEFVAR_LISP ("void-text-area-pointer", Vvoid_text_area_pointer,
 36943     doc: /* The pointer shape to show in void text areas.
 36944 A value of nil means to show the text pointer.  Other options are
 36945 `arrow', `text', `hand', `vdrag', `hdrag', `nhdrag', `modeline', and
 36946 `hourglass'.  */);
 36947   Vvoid_text_area_pointer = Qarrow;
 36948 
 36949   DEFVAR_LISP ("inhibit-redisplay", Vinhibit_redisplay,
 36950     doc: /* Non-nil means don't actually do any redisplay.
 36951 This is used for internal purposes.  */);
 36952   Vinhibit_redisplay = Qnil;
 36953 
 36954   DEFVAR_LISP ("global-mode-string", Vglobal_mode_string,
 36955     doc: /* String (or mode line construct) included (normally) in `mode-line-misc-info'.  */);
 36956   Vglobal_mode_string = Qnil;
 36957 
 36958   DEFVAR_LISP ("overlay-arrow-position", Voverlay_arrow_position,
 36959     doc: /* Marker for where to display an arrow on top of the buffer text.
 36960 This must be the beginning of a line in order to work.
 36961 See also `overlay-arrow-string'.  */);
 36962   Voverlay_arrow_position = Qnil;
 36963 
 36964   DEFVAR_LISP ("overlay-arrow-string", Voverlay_arrow_string,
 36965     doc: /* String to display as an arrow in non-window frames.
 36966 See also `overlay-arrow-position'.  */);
 36967   Voverlay_arrow_string = build_pure_c_string ("=>");
 36968 
 36969   DEFVAR_LISP ("overlay-arrow-variable-list", Voverlay_arrow_variable_list,
 36970     doc: /* List of variables (symbols) which hold markers for overlay arrows.
 36971 The symbols on this list are examined during redisplay to determine
 36972 where to display overlay arrows.  */);
 36973   Voverlay_arrow_variable_list
 36974     = list1 (intern_c_string ("overlay-arrow-position"));
 36975 
 36976   DEFVAR_INT ("scroll-step", emacs_scroll_step,
 36977     doc: /* The number of lines to try scrolling a window by when point moves out.
 36978 If that fails to bring point back on frame, point is centered instead.
 36979 If this is zero, point is always centered after it moves off frame.
 36980 If you want scrolling to always be a line at a time, you should set
 36981 `scroll-conservatively' to a large value rather than set this to 1.  */);
 36982 
 36983   DEFVAR_INT ("scroll-conservatively", scroll_conservatively,
 36984     doc: /* Scroll up to this many lines, to bring point back on screen.
 36985 If point moves off-screen, redisplay will scroll by up to
 36986 `scroll-conservatively' lines in order to bring point just barely
 36987 onto the screen again.  If that cannot be done, then redisplay
 36988 recenters point as usual.
 36989 
 36990 If the value is greater than 100, redisplay will never recenter point,
 36991 but will always scroll just enough text to bring point into view, even
 36992 if you move far away.
 36993 
 36994 A value of zero means always recenter point if it moves off screen.  */);
 36995   scroll_conservatively = 0;
 36996 
 36997   DEFVAR_INT ("scroll-margin", scroll_margin,
 36998     doc: /* Number of lines of margin at the top and bottom of a window.
 36999 Trigger automatic scrolling whenever point gets within this many lines
 37000 of the top or bottom of the window (see info node `Auto Scrolling').  */);
 37001   scroll_margin = 0;
 37002 
 37003   DEFVAR_LISP ("maximum-scroll-margin", Vmaximum_scroll_margin,
 37004     doc: /* Maximum effective value of `scroll-margin'.
 37005 Given as a fraction of the current window's lines.  The value should
 37006 be a floating point number between 0.0 and 0.5.  The effective maximum
 37007 is limited to (/ (1- window-lines) 2).  Non-float values for this
 37008 variable are ignored and the default 0.25 is used instead.  */);
 37009   Vmaximum_scroll_margin = make_float (0.25);
 37010 
 37011   DEFVAR_LISP ("display-pixels-per-inch",  Vdisplay_pixels_per_inch,
 37012     doc: /* Pixels per inch value for non-window system displays.
 37013 Value is a number or a cons (WIDTH-DPI . HEIGHT-DPI).  */);
 37014   Vdisplay_pixels_per_inch = make_float (72.0);
 37015 
 37016 #ifdef GLYPH_DEBUG
 37017   DEFVAR_INT ("debug-end-pos", debug_end_pos, doc: /* Don't ask.  */);
 37018 #endif
 37019 
 37020   DEFVAR_LISP ("truncate-partial-width-windows",
 37021                Vtruncate_partial_width_windows,
 37022     doc: /* Non-nil means truncate lines in windows narrower than the frame.
 37023 For an integer value, truncate lines in each window narrower than the
 37024 full frame width, provided the total window width in column units is less
 37025 than that integer; otherwise, respect the value of `truncate-lines'.
 37026 The total width of the window is as returned by `window-total-width', it
 37027 includes the fringes, the continuation and truncation glyphs, the
 37028 display margins (if any), and the scroll bar
 37029 
 37030 For any other non-nil value, truncate lines in all windows that do
 37031 not span the full frame width.
 37032 
 37033 A value of nil means to respect the value of `truncate-lines'.
 37034 
 37035 If `word-wrap' is enabled, you might want to reduce the value of this.
 37036 
 37037 Don't set this to a non-nil value when `visual-line-mode' is
 37038 turned on, as it could produce confusing results.  */);
 37039   Vtruncate_partial_width_windows = make_fixnum (50);
 37040 
 37041   DEFVAR_BOOL("word-wrap-by-category", word_wrap_by_category, doc: /*
 37042     Non-nil means also wrap after characters of a certain category.
 37043 Normally when `word-wrap' is on, Emacs only breaks lines after
 37044 whitespace characters.  When this option is turned on, Emacs also
 37045 breaks lines after characters that have the "|" category (defined in
 37046 characters.el).  This is useful for allowing breaking after CJK
 37047 characters and improves the word-wrapping for CJK text mixed with
 37048 Latin text.
 37049 
 37050 If this variable is set using Customize, Emacs automatically loads
 37051 kinsoku.el.  When kinsoku.el is loaded, Emacs respects kinsoku rules
 37052 when breaking lines.  That means characters with the ">" category
 37053 don't appear at the beginning of a line (e.g., FULLWIDTH COMMA), and
 37054 characters with the "<" category don't appear at the end of a line
 37055 (e.g., LEFT DOUBLE ANGLE BRACKET).  */);
 37056   word_wrap_by_category = false;
 37057 
 37058   DEFVAR_LISP ("line-number-display-limit", Vline_number_display_limit,
 37059     doc: /* Maximum buffer size for which line number should be displayed.
 37060 If the buffer is bigger than this, the line number does not appear
 37061 in the mode line.  A value of nil means no limit.  */);
 37062   Vline_number_display_limit = Qnil;
 37063 
 37064   DEFVAR_INT ("line-number-display-limit-width",
 37065               line_number_display_limit_width,
 37066     doc: /* Maximum line width (in characters) for line number display.
 37067 If the average length of the lines near point is bigger than this, then the
 37068 line number may be omitted from the mode line.  */);
 37069   line_number_display_limit_width = 200;
 37070 
 37071   DEFVAR_BOOL ("highlight-nonselected-windows", highlight_nonselected_windows,
 37072     doc: /* Non-nil means highlight active region even in nonselected windows.
 37073 When nil (the default), the active region is only highlighted when
 37074 the window is selected.  */);
 37075   highlight_nonselected_windows = false;
 37076 
 37077   DEFVAR_BOOL ("multiple-frames", multiple_frames,
 37078     doc: /* Non-nil if more than one frame is visible on this display.
 37079 Minibuffer-only frames don't count, but iconified frames do.
 37080 This variable is not guaranteed to be accurate except while processing
 37081 `frame-title-format' and `icon-title-format'.  */);
 37082 
 37083   DEFVAR_LISP ("frame-title-format", Vframe_title_format,
 37084     doc: /* Template for displaying the title bar of visible frames.
 37085 \(Assuming the window manager supports this feature.)
 37086 
 37087 This variable has the same structure as `mode-line-format', except that
 37088 the %c, %C, and %l constructs are ignored.  It is used only on frames for
 37089 which no explicit name has been set (see `modify-frame-parameters').  */);
 37090 
 37091   DEFVAR_LISP ("icon-title-format", Vicon_title_format,
 37092     doc: /* Template for displaying the title bar of an iconified frame.
 37093 \(Assuming the window manager supports this feature.)
 37094 If the value is a string, it should have the same structure
 37095 as `mode-line-format' (which see), and is used only on frames
 37096 for which no explicit name has been set \(see `modify-frame-parameters').
 37097 If the value is t, that means use `frame-title-format' for
 37098 iconified frames.  */);
 37099   /* Do not nest calls to pure_list.  This works around a bug in
 37100      Oracle Developer Studio 12.6.  */
 37101   Lisp_Object icon_title_name_format
 37102     = pure_list (empty_unibyte_string,
 37103                  build_pure_c_string ("%b - GNU Emacs at "),
 37104                  intern_c_string ("system-name"));
 37105   Vicon_title_format
 37106     = Vframe_title_format
 37107     = pure_list (intern_c_string ("multiple-frames"),
 37108                  build_pure_c_string ("%b"),
 37109                  icon_title_name_format);
 37110 
 37111   DEFVAR_LISP ("message-log-max", Vmessage_log_max,
 37112     doc: /* Maximum number of lines to keep in the message log buffer.
 37113 If nil, disable message logging.  If t, log messages but don't truncate
 37114 the buffer when it becomes large.  */);
 37115   Vmessage_log_max = make_fixnum (1000);
 37116 
 37117   DEFVAR_LISP ("window-scroll-functions", Vwindow_scroll_functions,
 37118     doc: /* List of functions to call before redisplaying a window with scrolling.
 37119 Each function is called with two arguments, the window and its new
 37120 display-start position.
 37121 These functions are called whenever the `window-start' marker is modified,
 37122 either to point into another buffer (e.g. via `set-window-buffer') or another
 37123 place in the same buffer.
 37124 When each function is called, the `window-start' marker of its window
 37125 argument has been already set to the new value, and the buffer which that
 37126 window will display is set to be the current buffer.
 37127 Note that the value of `window-end' is not valid when these functions are
 37128 called.
 37129 
 37130 Warning: Do not use this feature to alter the way the window
 37131 is scrolled.  It is not designed for that, and such use probably won't
 37132 work.  */);
 37133   Vwindow_scroll_functions = Qnil;
 37134 
 37135   DEFVAR_LISP ("mouse-autoselect-window", Vmouse_autoselect_window,
 37136      doc: /* Non-nil means autoselect window with mouse pointer.
 37137 If nil, do not autoselect windows.
 37138 A positive number means delay autoselection by that many seconds: a
 37139 window is autoselected only after the mouse has remained in that
 37140 window for the duration of the delay.
 37141 A negative number has a similar effect, but causes windows to be
 37142 autoselected only after the mouse has stopped moving.  (Because of
 37143 the way Emacs compares mouse events, you will occasionally wait twice
 37144 that time before the window gets selected.)
 37145 Any other value means to autoselect window instantaneously when the
 37146 mouse pointer enters it.
 37147 
 37148 Autoselection selects the minibuffer only if it is active, and never
 37149 unselects the minibuffer if it is active.
 37150 
 37151 If you want to use the mouse to autoselect a window on another frame,
 37152 make sure that (1) your window manager has focus follow the mouse and
 37153 (2) the value of the option `focus-follows-mouse' matches the policy
 37154 of your window manager.  */);
 37155   Vmouse_autoselect_window = Qnil;
 37156 
 37157   DEFVAR_LISP ("auto-resize-tab-bars", Vauto_resize_tab_bars,
 37158     doc: /* Non-nil means automatically resize tab-bars.
 37159 This dynamically changes the tab-bar's height to the minimum height
 37160 that is needed to make all tab-bar items visible.
 37161 If value is `grow-only', the tab-bar's height is only increased
 37162 automatically; to decrease the tab-bar height, use \\[recenter],
 37163 after setting `recenter-redisplay' to the value of t.  */);
 37164   Vauto_resize_tab_bars = Qt;
 37165 
 37166   DEFVAR_BOOL ("auto-raise-tab-bar-buttons", auto_raise_tab_bar_buttons_p,
 37167     doc: /* Non-nil means raise tab-bar buttons when the mouse moves over them.  */);
 37168   auto_raise_tab_bar_buttons_p = true;
 37169 
 37170   DEFVAR_LISP ("auto-resize-tool-bars", Vauto_resize_tool_bars,
 37171     doc: /* Non-nil means automatically resize tool-bars.
 37172 This dynamically changes the tool-bar's height to the minimum height
 37173 that is needed to make all tool-bar items visible.
 37174 If value is `grow-only', the tool-bar's height is only increased
 37175 automatically; to decrease the tool-bar height, use \\[recenter],
 37176 after setting `recenter-redisplay' to the value of t.  */);
 37177   Vauto_resize_tool_bars = Qt;
 37178 
 37179   DEFVAR_BOOL ("auto-raise-tool-bar-buttons", auto_raise_tool_bar_buttons_p,
 37180     doc: /* Non-nil means raise tool-bar buttons when the mouse moves over them.  */);
 37181   auto_raise_tool_bar_buttons_p = true;
 37182 
 37183   DEFVAR_LISP ("make-cursor-line-fully-visible", Vmake_cursor_line_fully_visible,
 37184     doc: /* Whether to scroll the window if the cursor line is not fully visible.
 37185 If the value is non-nil, Emacs scrolls or recenters the window to make
 37186 the cursor line fully visible.  The value could also be a function, which
 37187 is called with a single argument, the window to be scrolled, and should
 37188 return non-nil if the partially-visible cursor requires scrolling the
 37189 window, nil if it's okay to leave the cursor partially-visible.  */);
 37190   Vmake_cursor_line_fully_visible = Qt;
 37191   DEFSYM (Qmake_cursor_line_fully_visible, "make-cursor-line-fully-visible");
 37192 
 37193   DEFVAR_BOOL ("make-window-start-visible", make_window_start_visible,
 37194     doc: /* Whether to ensure `window-start' position is never invisible.  */);
 37195   make_window_start_visible = false;
 37196   DEFSYM (Qmake_window_start_visible, "make-window-start-visible");
 37197   Fmake_variable_buffer_local (Qmake_window_start_visible);
 37198 
 37199   DEFSYM (Qclose_tab, "close-tab");
 37200   DEFVAR_LISP ("tab-bar-border", Vtab_bar_border,
 37201     doc: /* Border below tab-bar in pixels.
 37202 If an integer, use it as the height of the border.
 37203 If it is one of `internal-border-width' or `border-width', use the
 37204 value of the corresponding frame parameter.
 37205 Otherwise, no border is added below the tab-bar.  */);
 37206   Vtab_bar_border = Qinternal_border_width;
 37207 
 37208   DEFVAR_LISP ("tab-bar-button-margin", Vtab_bar_button_margin,
 37209     doc: /* Margin around tab-bar buttons in pixels.
 37210 If an integer, use that for both horizontal and vertical margins.
 37211 Otherwise, value should be a pair of integers `(HORZ . VERT)' with
 37212 HORZ specifying the horizontal margin, and VERT specifying the
 37213 vertical margin.  */);
 37214   Vtab_bar_button_margin = make_fixnum (DEFAULT_TAB_BAR_BUTTON_MARGIN);
 37215 
 37216   DEFVAR_INT ("tab-bar-button-relief", tab_bar_button_relief,
 37217     doc: /* Relief thickness of tab-bar buttons.  */);
 37218   tab_bar_button_relief = DEFAULT_TAB_BAR_BUTTON_RELIEF;
 37219 
 37220   DEFVAR_LISP ("tool-bar-border", Vtool_bar_border,
 37221     doc: /* Border below tool-bar in pixels.
 37222 If an integer, use it as the height of the border.
 37223 If it is one of `internal-border-width' or `border-width', use the
 37224 value of the corresponding frame parameter.
 37225 Otherwise, no border is added below the tool-bar.  */);
 37226   Vtool_bar_border = Qinternal_border_width;
 37227 
 37228   DEFVAR_LISP ("tool-bar-button-margin", Vtool_bar_button_margin,
 37229     doc: /* Margin around tool-bar buttons in pixels.
 37230 If an integer, use that for both horizontal and vertical margins.
 37231 Otherwise, value should be a pair of integers `(HORZ . VERT)' with
 37232 HORZ specifying the horizontal margin, and VERT specifying the
 37233 vertical margin.  */);
 37234   Vtool_bar_button_margin = make_fixnum (DEFAULT_TOOL_BAR_BUTTON_MARGIN);
 37235 
 37236   DEFVAR_INT ("tool-bar-button-relief", tool_bar_button_relief,
 37237     doc: /* Relief thickness of tool-bar buttons.  */);
 37238   tool_bar_button_relief = DEFAULT_TOOL_BAR_BUTTON_RELIEF;
 37239 
 37240   DEFVAR_LISP ("tool-bar-style", Vtool_bar_style,
 37241     doc: /* Tool bar style to use.
 37242 It can be one of
 37243  image            - show images only
 37244  text             - show text only
 37245  both             - show both, text below image
 37246  both-horiz       - show text to the right of the image
 37247  text-image-horiz - show text to the left of the image
 37248  any other        - use system default or image if no system default.
 37249 
 37250 This variable only affects the GTK+ toolkit version of Emacs.  */);
 37251   Vtool_bar_style = Qnil;
 37252 
 37253   DEFVAR_INT ("tool-bar-max-label-size", tool_bar_max_label_size,
 37254     doc: /* Maximum number of characters a label can have to be shown.
 37255 The tool bar style must also show labels for this to have any effect, see
 37256 `tool-bar-style'.  */);
 37257   tool_bar_max_label_size = DEFAULT_TOOL_BAR_LABEL_SIZE;
 37258 
 37259   DEFVAR_LISP ("fontification-functions", Vfontification_functions,
 37260     doc: /* List of functions to call to fontify regions of text.
 37261 Each function is called with one argument POS.  Functions must
 37262 fontify a region starting at POS in the current buffer, and give
 37263 fontified regions the property `fontified' with a non-nil value.
 37264 
 37265 Note that, when `long-line-optimizations-p' is non-nil in the buffer,
 37266 these functions are called as if they were in a `with-restriction' form,
 37267 with a `long-line-optimizations-in-fontification-functions' label and
 37268 with the buffer narrowed to a portion around POS whose size is
 37269 specified by `long-line-optimizations-region-size'.  */);
 37270   Vfontification_functions = Qnil;
 37271   Fmake_variable_buffer_local (Qfontification_functions);
 37272 
 37273   DEFVAR_BOOL ("unibyte-display-via-language-environment",
 37274                unibyte_display_via_language_environment,
 37275     doc: /* Non-nil means display unibyte text according to language environment.
 37276 Specifically, this means that raw bytes in the range 160-255 decimal
 37277 are displayed by converting them to the equivalent multibyte characters
 37278 according to the current language environment.  As a result, they are
 37279 displayed according to the current fontset.
 37280 
 37281 Note that this variable affects only how these bytes are displayed,
 37282 but does not change the fact they are interpreted as raw bytes.  */);
 37283   unibyte_display_via_language_environment = false;
 37284 
 37285   DEFVAR_LISP ("max-mini-window-height", Vmax_mini_window_height,
 37286     doc: /* Maximum height for resizing mini-windows (the minibuffer and the echo area).
 37287 If a float, it specifies the maximum height in units of the
 37288 mini-window frame's height.
 37289 If an integer, it specifies the maximum height in units of the
 37290 mini-window frame's default font's height.  */);
 37291   Vmax_mini_window_height = make_float (0.25);
 37292 
 37293   DEFVAR_LISP ("resize-mini-windows", Vresize_mini_windows,
 37294     doc: /* How to resize mini-windows (the minibuffer and the echo area).
 37295 A value of nil means don't automatically resize mini-windows.
 37296 A value of t means resize them to fit the text displayed in them.
 37297 A value of `grow-only', the default, means let mini-windows grow only;
 37298 they return to their normal size when the minibuffer is closed, or the
 37299 echo area becomes empty.
 37300 
 37301 This variable does not affect resizing of the minibuffer window of
 37302 minibuffer-only frames.  These are handled by `resize-mini-frames'
 37303 only.  */);
 37304   /* Contrary to the doc string, we initialize this to nil, so that
 37305      loading loadup.el won't try to resize windows before loading
 37306      window.el, where some functions we need to call for this live.
 37307      We assign the 'grow-only' value right after loading window.el
 37308      during loadup.  */
 37309   Vresize_mini_windows = Qnil;
 37310 
 37311   DEFVAR_LISP ("blink-cursor-alist", Vblink_cursor_alist,
 37312     doc: /* Alist specifying how to blink the cursor off.
 37313 Each element has the form (ON-STATE . OFF-STATE).  Whenever the
 37314 `cursor-type' frame-parameter or variable equals ON-STATE,
 37315 comparing using `equal', Emacs uses OFF-STATE to specify
 37316 how to blink it off.  ON-STATE and OFF-STATE are values for
 37317 the `cursor-type' frame parameter.
 37318 
 37319 If a frame's ON-STATE has no entry in this list,
 37320 the frame's other specifications determine how to blink the cursor off.  */);
 37321   Vblink_cursor_alist = Qnil;
 37322 
 37323   DEFVAR_LISP ("auto-hscroll-mode", automatic_hscrolling,
 37324     doc: /* Allow or disallow automatic horizontal scrolling of windows.
 37325 The value `current-line' means the line displaying point in each window
 37326 is automatically scrolled horizontally to make point visible.
 37327 Any other non-nil value means all the lines in a window are automatically
 37328 scrolled horizontally to make point visible.  */);
 37329   automatic_hscrolling = Qt;
 37330   DEFSYM (Qauto_hscroll_mode, "auto-hscroll-mode");
 37331   DEFSYM (Qcurrent_line, "current-line");
 37332 
 37333   DEFVAR_INT ("hscroll-margin", hscroll_margin,
 37334     doc: /* How many columns away from the window edge point is allowed to get
 37335 before automatic hscrolling will horizontally scroll the window.  */);
 37336   hscroll_margin = 5;
 37337 
 37338   DEFVAR_LISP ("hscroll-step", Vhscroll_step,
 37339     doc: /* How many columns to scroll the window when point gets too close to the edge.
 37340 When point is less than `hscroll-margin' columns from the window
 37341 edge, automatic hscrolling will scroll the window by the amount of columns
 37342 determined by this variable.  If its value is a positive integer, scroll that
 37343 many columns.  If it's a positive floating-point number, it specifies the
 37344 fraction of the window's width to scroll.  If it's nil or zero, point will be
 37345 centered horizontally after the scroll.  Any other value, including negative
 37346 numbers, are treated as if the value were zero.
 37347 
 37348 Automatic hscrolling always moves point outside the scroll margin, so if
 37349 point was more than scroll step columns inside the margin, the window will
 37350 scroll more than the value given by the scroll step.
 37351 
 37352 Note that the lower bound for automatic hscrolling specified by `scroll-left'
 37353 and `scroll-right' overrides this variable's effect.  */);
 37354   Vhscroll_step = make_fixnum (0);
 37355 
 37356   DEFVAR_BOOL ("message-truncate-lines", message_truncate_lines,
 37357     doc: /* If non-nil, messages are truncated when displaying the echo area.
 37358 Bind this around calls to `message' to let it take effect.  */);
 37359   message_truncate_lines = false;
 37360 
 37361   DEFVAR_LISP ("menu-bar-update-hook",  Vmenu_bar_update_hook,
 37362     doc: /* Normal hook run to update the menu bar definitions.
 37363 Redisplay runs this hook before it redisplays the menu bar.
 37364 This is used to update menus such as Buffers, whose contents depend on
 37365 various data.  */);
 37366   Vmenu_bar_update_hook = Qnil;
 37367 
 37368   DEFVAR_LISP ("menu-updating-frame", Vmenu_updating_frame,
 37369                doc: /* Frame for which we are updating a menu.
 37370 The enable predicate for a menu binding should check this variable.  */);
 37371   Vmenu_updating_frame = Qnil;
 37372 
 37373   DEFVAR_BOOL ("inhibit-menubar-update", inhibit_menubar_update,
 37374     doc: /* Non-nil means don't update menu bars.  Internal use only.  */);
 37375   inhibit_menubar_update = false;
 37376 
 37377   DEFVAR_LISP ("wrap-prefix", Vwrap_prefix,
 37378     doc: /* Prefix prepended to all continuation lines at display time.
 37379 The value may be a string, an image, or a stretch-glyph; it is
 37380 interpreted in the same way as the value of a `display' text property.
 37381 
 37382 This variable is overridden by any `wrap-prefix' text or overlay
 37383 property.
 37384 
 37385 To add a prefix to non-continuation lines, use `line-prefix'.  */);
 37386   Vwrap_prefix = Qnil;
 37387   DEFSYM (Qwrap_prefix, "wrap-prefix");
 37388   Fmake_variable_buffer_local (Qwrap_prefix);
 37389 
 37390   DEFVAR_LISP ("line-prefix", Vline_prefix,
 37391     doc: /* Prefix prepended to all non-continuation lines at display time.
 37392 The value may be a string, an image, or a stretch-glyph; it is
 37393 interpreted in the same way as the value of a `display' text property.
 37394 
 37395 This variable is overridden by any `line-prefix' text or overlay
 37396 property.
 37397 
 37398 To add a prefix to continuation lines, use `wrap-prefix'.  */);
 37399   Vline_prefix = Qnil;
 37400   DEFSYM (Qline_prefix, "line-prefix");
 37401   Fmake_variable_buffer_local (Qline_prefix);
 37402 
 37403   DEFVAR_LISP ("display-line-numbers", Vdisplay_line_numbers,
 37404     doc: /* Non-nil means display line numbers.
 37405 
 37406 If the value is t, display the absolute number of each line of a buffer
 37407 shown in a window.  Absolute line numbers count from the beginning of
 37408 the current narrowing, or from buffer beginning.  The variable
 37409 `display-line-numbers-offset', if non-zero, is a signed offset added
 37410 to each absolute line number; it also forces line numbers to be counted
 37411 from the beginning of the buffer, as if `display-line-numbers-widen'
 37412 were non-nil.  It has no effect when line numbers are not absolute.
 37413 
 37414 If the value is `relative', display for each line not containing the
 37415 window's point its relative number instead, i.e. the number of the line
 37416 relative to the line showing the window's point.
 37417 
 37418 In either case, line numbers are displayed at the beginning of each
 37419 non-continuation line that displays buffer text, i.e. after each newline
 37420 character that comes from the buffer.  The value `visual' is like
 37421 `relative' but counts screen lines instead of buffer lines.  In practice
 37422 this means that continuation lines count as well when calculating the
 37423 relative number of a line.
 37424 
 37425 Lisp programs can disable display of a line number of a particular
 37426 buffer line by putting the `display-line-numbers-disable' text property
 37427 or overlay property on the first visible character of that line.  */);
 37428   Vdisplay_line_numbers = Qnil;
 37429   DEFSYM (Qdisplay_line_numbers, "display-line-numbers");
 37430   Fmake_variable_buffer_local (Qdisplay_line_numbers);
 37431   DEFSYM (Qrelative, "relative");
 37432   DEFSYM (Qvisual, "visual");
 37433 
 37434   DEFVAR_LISP ("display-line-numbers-width", Vdisplay_line_numbers_width,
 37435     doc: /* Minimum width of space reserved for line number display.
 37436 A positive number means reserve that many columns for line numbers,
 37437 even if the actual number needs less space.
 37438 The default value of nil means compute the space dynamically.
 37439 Any other value is treated as nil.  */);
 37440   Vdisplay_line_numbers_width = Qnil;
 37441   DEFSYM (Qdisplay_line_numbers_width, "display-line-numbers-width");
 37442   Fmake_variable_buffer_local (Qdisplay_line_numbers_width);
 37443 
 37444   DEFVAR_LISP ("display-line-numbers-current-absolute",
 37445                Vdisplay_line_numbers_current_absolute,
 37446     doc: /* Non-nil means display absolute number of current line.
 37447 This variable has effect only when `display-line-numbers' is
 37448 either `relative' or `visual'.  */);
 37449   Vdisplay_line_numbers_current_absolute = Qt;
 37450 
 37451   DEFVAR_BOOL ("display-line-numbers-widen", display_line_numbers_widen,
 37452     doc: /* Non-nil means display line numbers disregarding any narrowing.  */);
 37453   display_line_numbers_widen = false;
 37454   DEFSYM (Qdisplay_line_numbers_widen, "display-line-numbers-widen");
 37455   Fmake_variable_buffer_local (Qdisplay_line_numbers_widen);
 37456 
 37457   DEFVAR_INT ("display-line-numbers-offset", display_line_numbers_offset,
 37458     doc: /* A signed integer added to each absolute line number.
 37459 When this variable is non-zero, line numbers are always counted from
 37460 the beginning of the buffer even if `display-line-numbers-widen' is nil.
 37461 It has no effect when set to 0, or when line numbers are not absolute.  */);
 37462   display_line_numbers_offset = 0;
 37463   DEFSYM (Qdisplay_line_numbers_offset, "display-line-numbers-offset");
 37464   Fmake_variable_buffer_local (Qdisplay_line_numbers_offset);
 37465 
 37466   DEFVAR_BOOL ("display-fill-column-indicator", display_fill_column_indicator,
 37467     doc: /* Non-nil means display the fill column indicator.
 37468 If you set this non-nil, make sure `display-fill-column-indicator-character'
 37469 is also non-nil.
 37470 See Info node `Displaying Boundaries' for details.  */);
 37471   display_fill_column_indicator = false;
 37472   DEFSYM (Qdisplay_fill_column_indicator, "display-fill-column-indicator");
 37473   Fmake_variable_buffer_local (Qdisplay_fill_column_indicator);
 37474 
 37475   DEFVAR_LISP ("display-fill-column-indicator-column", Vdisplay_fill_column_indicator_column,
 37476     doc: /* Column for indicator when `display-fill-column-indicator' is non-nil.
 37477 The default value is t which means that the indicator
 37478 will use the `fill-column' variable.  If it is set to an integer the
 37479 indicator will be drawn in that column.
 37480 See Info node `Displaying Boundaries' for details.  */);
 37481   Vdisplay_fill_column_indicator_column = Qt;
 37482   DEFSYM (Qdisplay_fill_column_indicator_column, "display-fill-column-indicator-column");
 37483   Fmake_variable_buffer_local (Qdisplay_fill_column_indicator_column);
 37484 
 37485   DEFVAR_LISP ("display-fill-column-indicator-character", Vdisplay_fill_column_indicator_character,
 37486     doc: /* Character to draw the indicator when `display-fill-column-indicator' is non-nil.
 37487 A good candidate is U+2502, and an alternative is (ascii 124) if the
 37488 font of `fill-column-indicator' face does not support Unicode characters.
 37489 See Info node `Displaying Boundaries' for details.  */);
 37490   Vdisplay_fill_column_indicator_character = Qnil;
 37491   DEFSYM (Qdisplay_fill_column_indicator_character, "display-fill-column-indicator-character");
 37492   Fmake_variable_buffer_local (Qdisplay_fill_column_indicator_character);
 37493 
 37494   DEFVAR_INT ("display-line-numbers-major-tick", display_line_numbers_major_tick,
 37495     doc: /* If an integer N > 0, highlight line number of every Nth line.
 37496 The line number is shown with the `line-number-major-tick' face.
 37497 Otherwise, no special highlighting is done every Nth line.
 37498 Note that major ticks take precedence over minor ticks.  */);
 37499   display_line_numbers_major_tick = 0;
 37500 
 37501   DEFVAR_INT ("display-line-numbers-minor-tick", display_line_numbers_minor_tick,
 37502     doc: /* If an integer N > 0, highlight line number of every Nth line.
 37503 The line number is shown with the `line-number-minor-tick' face.
 37504 Otherwise, no special highlighting is done every Nth line.
 37505 Note that major ticks take precedence over minor ticks.  */);
 37506   display_line_numbers_minor_tick = 0;
 37507 
 37508   DEFVAR_BOOL ("inhibit-eval-during-redisplay", inhibit_eval_during_redisplay,
 37509     doc: /* Non-nil means don't eval Lisp during redisplay.  */);
 37510   inhibit_eval_during_redisplay = false;
 37511 
 37512   DEFVAR_BOOL ("inhibit-free-realized-faces", inhibit_free_realized_faces,
 37513     doc: /* Non-nil means don't free realized faces.  Internal use only.  */);
 37514   inhibit_free_realized_faces = false;
 37515 
 37516   DEFVAR_BOOL ("inhibit-bidi-mirroring", inhibit_bidi_mirroring,
 37517     doc: /* Non-nil means don't mirror characters even when bidi context requires that.
 37518 Intended for use during debugging and for testing bidi display;
 37519 see biditest.el in the test suite.  */);
 37520   inhibit_bidi_mirroring = false;
 37521 
 37522   DEFVAR_BOOL ("bidi-inhibit-bpa", bidi_inhibit_bpa,
 37523     doc: /* Non-nil means inhibit the Bidirectional Parentheses Algorithm.
 37524 Disabling the BPA makes redisplay faster, but might produce incorrect
 37525 display reordering of bidirectional text with embedded parentheses and
 37526 other bracket characters whose `paired-bracket' Unicode property is
 37527 non-nil, see `get-char-code-property'.  */);
 37528   bidi_inhibit_bpa = false;
 37529 
 37530 #ifdef GLYPH_DEBUG
 37531   DEFVAR_BOOL ("inhibit-try-window-id", inhibit_try_window_id,
 37532                doc: /* Inhibit try_window_id display optimization.  */);
 37533   inhibit_try_window_id = false;
 37534 
 37535   DEFVAR_BOOL ("inhibit-try-window-reusing", inhibit_try_window_reusing,
 37536                doc: /* Inhibit try_window_reusing display optimization.  */);
 37537   inhibit_try_window_reusing = false;
 37538 
 37539   DEFVAR_BOOL ("inhibit-try-cursor-movement", inhibit_try_cursor_movement,
 37540                doc: /* Inhibit try_cursor_movement display optimization.  */);
 37541   inhibit_try_cursor_movement = false;
 37542 #endif /* GLYPH_DEBUG */
 37543 
 37544   DEFVAR_INT ("overline-margin", overline_margin,
 37545                doc: /* Space between overline and text, in pixels.
 37546 The default value is 2: the height of the overline (1 pixel) plus 1 pixel
 37547 margin to the character height.  */);
 37548   overline_margin = 2;
 37549 
 37550   DEFVAR_INT ("underline-minimum-offset",
 37551                underline_minimum_offset,
 37552      doc: /* Minimum distance between baseline and underline.
 37553 This can improve legibility of underlined text at small font sizes,
 37554 particularly when using variable `x-use-underline-position-properties'
 37555 with fonts that specify an UNDERLINE_POSITION relatively close to the
 37556 baseline.  The default value is 1.  */);
 37557   underline_minimum_offset = 1;
 37558   DEFSYM (Qunderline_minimum_offset, "underline-minimum-offset");
 37559 
 37560   DEFVAR_BOOL ("display-hourglass", display_hourglass_p,
 37561                doc: /* Non-nil means show an hourglass pointer, when Emacs is busy.
 37562 This feature only works when on a window system that can change
 37563 cursor shapes.  */);
 37564   display_hourglass_p = true;
 37565 
 37566   DEFVAR_LISP ("hourglass-delay", Vhourglass_delay,
 37567                doc: /* Seconds to wait before displaying an hourglass pointer when Emacs is busy.  */);
 37568   Vhourglass_delay = make_fixnum (DEFAULT_HOURGLASS_DELAY);
 37569 
 37570 #ifdef HAVE_WINDOW_SYSTEM
 37571   hourglass_atimer = NULL;
 37572   hourglass_shown_p = false;
 37573 #endif /* HAVE_WINDOW_SYSTEM */
 37574 
 37575   /* Name of the face used to display glyphless characters.  */
 37576   DEFSYM (Qglyphless_char, "glyphless-char");
 37577 
 37578   /* Method symbols for Vglyphless_char_display.  */
 37579   DEFSYM (Qhex_code, "hex-code");
 37580   DEFSYM (Qempty_box, "empty-box");
 37581   DEFSYM (Qthin_space, "thin-space");
 37582   DEFSYM (Qzero_width, "zero-width");
 37583 
 37584   DEFVAR_LISP ("pre-redisplay-function", Vpre_redisplay_function,
 37585                doc: /* Function run just before redisplay.
 37586 It is called with one argument, which is the set of windows that are to
 37587 be redisplayed.  This set can be nil (meaning, only the selected window),
 37588 or t (meaning all windows).  */);
 37589   Vpre_redisplay_function = intern ("ignore");
 37590 
 37591   /* Symbol for the purpose of Vglyphless_char_display.  */
 37592   DEFSYM (Qglyphless_char_display, "glyphless-char-display");
 37593   Fput (Qglyphless_char_display, Qchar_table_extra_slots, make_fixnum (1));
 37594 
 37595   DEFVAR_LISP ("glyphless-char-display", Vglyphless_char_display,
 37596                doc: /* Char-table defining glyphless characters.
 37597 Each element, if non-nil, should be one of the following:
 37598   an ASCII acronym string: display this string in a box
 37599   `hex-code':   display the hexadecimal code of a character in a box
 37600   `empty-box':  display as an empty box
 37601   `thin-space': display as 1-pixel width space
 37602   `zero-width': don't display
 37603 Any other value is interpreted as `empty-box'.
 37604 An element may also be a cons cell (GRAPHICAL . TEXT), which specifies the
 37605 display method for graphical terminals and text terminals respectively.
 37606 GRAPHICAL and TEXT should each have one of the values listed above.
 37607 
 37608 The char-table has one extra slot to control the display of characters
 37609 for which no font is found on graphical terminals, and characters that
 37610 cannot be displayed by text-mode terminals.  Its value should be an
 37611 ASCII acronym string, `hex-code', `empty-box', or `thin-space'.  It
 37612 could also be a cons cell of any two of these, to specify separate
 37613 values for graphical and text terminals.  The default is `empty-box'.
 37614 
 37615 With the obvious exception of `zero-width', all the other representations
 37616 are displayed using the face `glyphless-char'.
 37617 
 37618 If a character has a non-nil entry in an active display table, the
 37619 display table takes effect; in this case, Emacs does not consult
 37620 `glyphless-char-display' at all.  */);
 37621   Vglyphless_char_display = Fmake_char_table (Qglyphless_char_display, Qnil);
 37622   Fset_char_table_extra_slot (Vglyphless_char_display, make_fixnum (0),
 37623                               Qempty_box);
 37624 
 37625   DEFVAR_LISP ("debug-on-message", Vdebug_on_message,
 37626                doc: /* If non-nil, debug if a message matching this regexp is displayed.  */);
 37627   Vdebug_on_message = Qnil;
 37628 
 37629   DEFVAR_LISP ("set-message-function", Vset_message_function,
 37630                doc: /* If non-nil, function to handle display of echo-area messages.
 37631 The function is called with one argument that is the text of a message.
 37632 If this function returns nil, the message is displayed in the echo area
 37633 as usual.  If the function returns a string, the returned string is
 37634 displayed in the echo area.  If this function returns any other non-nil
 37635 value, this means that the message was already handled, and the original
 37636 message text will not be displayed in the echo area.
 37637 
 37638 Also see `clear-message-function' (which can be used to clear the
 37639 message displayed by this function), and `command-error-function'
 37640 (which controls how error messages are displayed).  */);
 37641   Vset_message_function = Qnil;
 37642 
 37643   DEFSYM (Qdont_clear_message, "dont-clear-message");
 37644   DEFVAR_LISP ("clear-message-function", Vclear_message_function,
 37645                doc: /* If non-nil, function to clear echo-area messages.
 37646 Usually this function is called when the next input event arrives.
 37647 It is expected to clear the message displayed by its counterpart
 37648 function specified by `set-message-function'.
 37649 
 37650 The function is called without arguments.
 37651 
 37652 If this function returns a value that isn't `dont-clear-message', the
 37653 message is cleared from the echo area as usual.  If this function
 37654 returns `dont-clear-message', this means that the message was already
 37655 handled, and the original message text will not be cleared from the
 37656 echo area.  */);
 37657   Vclear_message_function = Qnil;
 37658 
 37659   DEFVAR_LISP ("redisplay--all-windows-cause", Vredisplay__all_windows_cause,
 37660                doc: /* Code of the cause for redisplaying all windows.
 37661 Internal use only.  */);
 37662   Vredisplay__all_windows_cause = Fmake_hash_table (0, NULL);
 37663 
 37664   DEFVAR_LISP ("redisplay--mode-lines-cause", Vredisplay__mode_lines_cause,
 37665                doc: /* Code of the cause for redisplaying mode lines.
 37666 Internal use only.  */);
 37667   Vredisplay__mode_lines_cause = Fmake_hash_table (0, NULL);
 37668 
 37669   DEFVAR_BOOL ("redisplay--inhibit-bidi", redisplay__inhibit_bidi,
 37670      doc: /* Non-nil means it is not safe to attempt bidi reordering for display.  */);
 37671   /* Initialize to t, since we need to disable reordering until
 37672      loadup.el successfully loads charprop.el.  */
 37673   redisplay__inhibit_bidi = true;
 37674 
 37675   DEFVAR_BOOL ("display-raw-bytes-as-hex", display_raw_bytes_as_hex,
 37676     doc: /* Non-nil means display raw bytes in hexadecimal format.
 37677 The default is to use octal format (\\200) whereas hexadecimal (\\x80)
 37678 may be more familiar to users.  */);
 37679   display_raw_bytes_as_hex = false;
 37680 
 37681   DEFVAR_BOOL ("mouse-fine-grained-tracking", mouse_fine_grained_tracking,
 37682     doc: /* Non-nil for pixel-wise mouse-movement.
 37683 When nil, mouse-movement events will not be generated as long as the
 37684 mouse stays within the extent of a single glyph (except for images).  */);
 37685   mouse_fine_grained_tracking = false;
 37686 
 37687   DEFVAR_BOOL ("tab-bar--dragging-in-progress", tab_bar__dragging_in_progress,
 37688     doc: /* Non-nil when maybe dragging tab bar item.  */);
 37689   tab_bar__dragging_in_progress = false;
 37690 
 37691   DEFVAR_BOOL ("redisplay-skip-initial-frame", redisplay_skip_initial_frame,
 37692     doc: /* Non-nil means skip redisplay of the initial frame.
 37693 The initial frame is the text-mode frame used by Emacs internally during
 37694 the early stages of startup.  That frame is not displayed anywhere, so
 37695 skipping it is best except in special circumstances such as running
 37696 redisplay tests in batch mode.   */);
 37697   redisplay_skip_initial_frame = true;
 37698 
 37699   DEFVAR_BOOL ("redisplay-skip-fontification-on-input",
 37700                redisplay_skip_fontification_on_input,
 37701     doc: /* Skip `fontification_functions` when there is input pending.
 37702 If non-nil and there was input pending at the beginning of the command,
 37703 the `fontification_functions` hook is not run.  This usually does not
 37704 affect the display because redisplay is completely skipped anyway if input
 37705 was pending, but it can make scrolling smoother by avoiding
 37706 unnecessary fontification.
 37707 It is similar to `fast-but-imprecise-scrolling' with similar tradeoffs,
 37708 but with the advantage that it should only affect the behavior when Emacs
 37709 has trouble keeping up with the incoming input rate.  */);
 37710   redisplay_skip_fontification_on_input = false;
 37711 
 37712   DEFVAR_BOOL ("redisplay-adhoc-scroll-in-resize-mini-windows",
 37713                redisplay_adhoc_scroll_in_resize_mini_windows,
 37714     doc: /* If nil always use normal scrolling in minibuffer windows.
 37715 Otherwise, use custom-tailored code after resizing minibuffer windows to try
 37716 and display the most important part of the minibuffer.   */);
 37717   /* See bug#43519 for some discussion around this.  */
 37718   redisplay_adhoc_scroll_in_resize_mini_windows = true;
 37719 
 37720   DEFVAR_BOOL ("composition-break-at-point", composition_break_at_point,
 37721     doc: /* If non-nil, prevent auto-composition of characters around point.
 37722 This makes it easier to edit character sequences that are
 37723 composed on display.  */);
 37724   composition_break_at_point = false;
 37725 
 37726   DEFVAR_INT ("max-redisplay-ticks", max_redisplay_ticks,
 37727     doc: /* Maximum number of redisplay ticks before aborting redisplay of a window.
 37728 
 37729 This allows to abort the display of a window if the amount of low-level
 37730 redisplay operations exceeds the value of this variable.  When display of
 37731 a window is aborted due to this reason, the buffer shown in that window
 37732 will not have its windows redisplayed until the buffer is modified or until
 37733 you type \\[recenter-top-bottom] with one of its windows selected.
 37734 You can also decide to kill the buffer and visit it in some
 37735 other way, like under `so-long-mode' or literally.
 37736 
 37737 The default value is zero, which disables this feature.
 37738 The recommended non-zero value is between 100000 and 1000000,
 37739 depending on your patience and the speed of your system.  */);
 37740   max_redisplay_ticks = 0;
 37741 }
 37742 
 37743 
 37744 /* Initialize this module when Emacs starts.  */
 37745 
 37746 void
 37747 init_xdisp (void)
 37748 {
 37749   CHARPOS (this_line_start_pos) = 0;
 37750 
 37751   echo_area_window = minibuf_window;
 37752 
 37753   if (!noninteractive)
 37754     {
 37755       struct window *m = XWINDOW (minibuf_window);
 37756       Lisp_Object frame = m->frame;
 37757       struct frame *f = XFRAME (frame);
 37758       Lisp_Object root = FRAME_ROOT_WINDOW (f);
 37759       struct window *r = XWINDOW (root);
 37760       int i;
 37761 
 37762       r->top_line = FRAME_TOP_MARGIN (f);
 37763       r->pixel_top = r->top_line * FRAME_LINE_HEIGHT (f);
 37764       r->total_cols = FRAME_COLS (f);
 37765       r->pixel_width = r->total_cols * FRAME_COLUMN_WIDTH (f);
 37766       r->total_lines = FRAME_TOTAL_LINES (f) - 1 - FRAME_MARGINS (f);
 37767       r->pixel_height = r->total_lines * FRAME_LINE_HEIGHT (f);
 37768 
 37769       m->top_line = FRAME_TOTAL_LINES (f) - 1;
 37770       m->pixel_top = m->top_line * FRAME_LINE_HEIGHT (f);
 37771       m->total_cols = FRAME_COLS (f);
 37772       m->pixel_width = m->total_cols * FRAME_COLUMN_WIDTH (f);
 37773       m->total_lines = 1;
 37774       m->pixel_height = m->total_lines * FRAME_LINE_HEIGHT (f);
 37775 
 37776       scratch_glyph_row.glyphs[TEXT_AREA] = scratch_glyphs;
 37777       scratch_glyph_row.glyphs[TEXT_AREA + 1]
 37778         = scratch_glyphs + MAX_SCRATCH_GLYPHS;
 37779 
 37780       /* The default ellipsis glyphs `...'.  */
 37781       for (i = 0; i < 3; ++i)
 37782         default_invis_vector[i] = make_fixnum ('.');
 37783     }
 37784 
 37785   {
 37786     /* Allocate the buffer for frame titles.
 37787        Also used for `format-mode-line'.  */
 37788     int size = 100;
 37789     mode_line_noprop_buf = xmalloc (size);
 37790     mode_line_noprop_buf_end = mode_line_noprop_buf + size;
 37791     mode_line_noprop_ptr = mode_line_noprop_buf;
 37792     mode_line_target = MODE_LINE_DISPLAY;
 37793   }
 37794 
 37795   help_echo_showing_p = false;
 37796 }
 37797 
 37798 #ifdef HAVE_WINDOW_SYSTEM
 37799 
 37800 /* Platform-independent portion of hourglass implementation.  */
 37801 
 37802 /* Timer function of hourglass_atimer.  */
 37803 
 37804 static void
 37805 show_hourglass (struct atimer *timer)
 37806 {
 37807   /* The timer implementation will cancel this timer automatically
 37808      after this function has run.  Set hourglass_atimer to null
 37809      so that we know the timer doesn't have to be canceled.  */
 37810   hourglass_atimer = NULL;
 37811 
 37812   if (!hourglass_shown_p)
 37813     {
 37814       Lisp_Object tail, frame;
 37815 
 37816       block_input ();
 37817 
 37818       FOR_EACH_FRAME (tail, frame)
 37819         {
 37820           struct frame *f = XFRAME (frame);
 37821 
 37822           if (FRAME_LIVE_P (f) && FRAME_WINDOW_P (f)
 37823               && FRAME_RIF (f)->show_hourglass)
 37824             FRAME_RIF (f)->show_hourglass (f);
 37825         }
 37826 
 37827       hourglass_shown_p = true;
 37828       unblock_input ();
 37829     }
 37830 }
 37831 
 37832 /* Cancel a currently active hourglass timer, and start a new one.  */
 37833 
 37834 void
 37835 start_hourglass (void)
 37836 {
 37837   struct timespec delay;
 37838 
 37839   cancel_hourglass ();
 37840 
 37841   if (FIXNUMP (Vhourglass_delay)
 37842       && XFIXNUM (Vhourglass_delay) > 0)
 37843     delay = make_timespec (min (XFIXNUM (Vhourglass_delay),
 37844                                   TYPE_MAXIMUM (time_t)),
 37845                            0);
 37846   else if (FLOATP (Vhourglass_delay)
 37847            && XFLOAT_DATA (Vhourglass_delay) > 0)
 37848     delay = dtotimespec (XFLOAT_DATA (Vhourglass_delay));
 37849   else
 37850     delay = make_timespec (DEFAULT_HOURGLASS_DELAY, 0);
 37851 
 37852   hourglass_atimer = start_atimer (ATIMER_RELATIVE, delay,
 37853                                    show_hourglass, NULL);
 37854 }
 37855 
 37856 /* Cancel the hourglass cursor timer if active, hide a busy cursor if
 37857    shown.  */
 37858 
 37859 void
 37860 cancel_hourglass (void)
 37861 {
 37862   if (hourglass_atimer)
 37863     {
 37864       cancel_atimer (hourglass_atimer);
 37865       hourglass_atimer = NULL;
 37866     }
 37867 
 37868   if (hourglass_shown_p)
 37869     {
 37870       Lisp_Object tail, frame;
 37871 
 37872       block_input ();
 37873 
 37874       FOR_EACH_FRAME (tail, frame)
 37875         {
 37876           struct frame *f = XFRAME (frame);
 37877 
 37878           if (FRAME_LIVE_P (f) && FRAME_WINDOW_P (f)
 37879               && FRAME_RIF (f)->hide_hourglass)
 37880             FRAME_RIF (f)->hide_hourglass (f);
 37881 #ifdef HAVE_NTGUI
 37882           /* No cursors on non GUI frames - restore to stock arrow cursor.  */
 37883           else if (!FRAME_W32_P (f))
 37884             w32_arrow_cursor ();
 37885 #endif
 37886         }
 37887 
 37888       hourglass_shown_p = false;
 37889       unblock_input ();
 37890     }
 37891 }
 37892 
 37893 /* Return a correction to be applied to G->pixel_width when it is
 37894    displayed in MOUSE_FACE.  This is needed for the first and the last
 37895    glyphs of text inside a face with :box when it is displayed with
 37896    MOUSE_FACE that has a different or no :box attribute.
 37897    ORIGINAL_FACE is the face G was originally drawn in, and MOUSE_FACE
 37898    is the face it will be drawn in now.  ROW is the G's glyph row and
 37899    W is its window.  */
 37900 static int
 37901 adjust_glyph_width_for_mouse_face (struct glyph *g, struct glyph_row *row,
 37902                                    struct window *w,
 37903                                    struct face *original_face,
 37904                                    struct face *mouse_face)
 37905 {
 37906   int sum = 0;
 37907 
 37908   bool do_left_box_p = g->left_box_line_p;
 37909   bool do_right_box_p = g->right_box_line_p;
 37910 
 37911   /* This is required because we test some parameters of the image
 37912      slice before applying the box in produce_image_glyph.  */
 37913   if (g->type == IMAGE_GLYPH)
 37914     {
 37915       if (!row->reversed_p)
 37916         {
 37917           struct image *img = IMAGE_FROM_ID (WINDOW_XFRAME (w),
 37918                                              g->u.img_id);
 37919           do_left_box_p = g->left_box_line_p &&
 37920             g->slice.img.x == 0;
 37921           do_right_box_p = g->right_box_line_p &&
 37922             g->slice.img.x + g->slice.img.width == img->width;
 37923         }
 37924       else
 37925         {
 37926           struct image *img = IMAGE_FROM_ID (WINDOW_XFRAME (w),
 37927                                              g->u.img_id);
 37928           do_left_box_p = g->left_box_line_p &&
 37929             g->slice.img.x + g->slice.img.width == img->width;
 37930           do_right_box_p = g->right_box_line_p &&
 37931             g->slice.img.x == 0;
 37932         }
 37933     }
 37934 
 37935   /* If the glyph has a left box line, subtract it from the offset.  */
 37936   if (do_left_box_p)
 37937     sum -= max (0, original_face->box_vertical_line_width);
 37938   /* Likewise with the right box line, as there may be a
 37939      box there as well.  */
 37940   if (do_right_box_p)
 37941     sum -= max (0, original_face->box_vertical_line_width);
 37942   /* Now add the line widths from the new face.  */
 37943   if (g->left_box_line_p)
 37944     sum += max (0, mouse_face->box_vertical_line_width);
 37945   if (g->right_box_line_p)
 37946     sum += max (0, mouse_face->box_vertical_line_width);
 37947 
 37948   return sum;
 37949 }
 37950 
 37951 /* Get the offset due to mouse-highlight to apply before drawing
 37952    phys_cursor, and return it in OFFSET.  ROW should be the row that
 37953    is under mouse face and contains the phys cursor.
 37954 
 37955    This is required because the produce_XXX_glyph series of functions
 37956    add the width of the various vertical box lines to the total width
 37957    of the glyphs, but that must be updated when the row is put under
 37958    mouse face, which can have different box dimensions.  */
 37959 static void
 37960 get_cursor_offset_for_mouse_face (struct window *w, struct glyph_row *row,
 37961                                   int *offset)
 37962 {
 37963   int sum = 0;
 37964   /* Return because the mode line can't possibly have a cursor. */
 37965   if (row->mode_line_p)
 37966     return;
 37967 
 37968   block_input ();
 37969 
 37970   struct frame *f = WINDOW_XFRAME (w);
 37971   Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (f);
 37972   struct glyph *start, *end;
 37973   struct face *mouse_face = FACE_FROM_ID (f, hlinfo->mouse_face_face_id);
 37974   int hpos = w->phys_cursor.hpos;
 37975   end = &row->glyphs[TEXT_AREA][hpos];
 37976 
 37977   if (!row->reversed_p)
 37978     {
 37979       if (MATRIX_ROW_VPOS (row, w->current_matrix) ==
 37980           hlinfo->mouse_face_beg_row)
 37981         start = &row->glyphs[TEXT_AREA][hlinfo->mouse_face_beg_col];
 37982       else
 37983         start = row->glyphs[TEXT_AREA];
 37984     }
 37985   else
 37986     {
 37987       if (MATRIX_ROW_VPOS (row, w->current_matrix) ==
 37988           hlinfo->mouse_face_end_row)
 37989         start = &row->glyphs[TEXT_AREA][hlinfo->mouse_face_end_col];
 37990       else
 37991         start = &row->glyphs[TEXT_AREA][row->used[TEXT_AREA] - 1];
 37992     }
 37993 
 37994   /* Calculate the offset by which to correct phys_cursor x if we are
 37995      drawing the cursor inside mouse-face highlighted text.  */
 37996 
 37997   for ( ; row->reversed_p ? start > end : start < end;
 37998           row->reversed_p ? --start : ++start)
 37999     sum += adjust_glyph_width_for_mouse_face (start, row, w,
 38000                                               FACE_FROM_ID (f, start->face_id),
 38001                                               mouse_face);
 38002 
 38003   if (row->reversed_p)
 38004     sum = -sum;
 38005 
 38006   *offset = sum;
 38007 
 38008   unblock_input ();
 38009 }
 38010 #endif /* HAVE_WINDOW_SYSTEM */